Lines Matching defs:u32
7706 typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
7714 ** that can be stored in a u32 without loss of data. The value
7991 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
8034 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
8035 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
8087 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
8090 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
8091 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
8098 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
8532 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
8533 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
8534 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
8626 typedef u32 Pgno;
8696 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int);
8811 u32 pageHash; /* Hash of page content */
9466 u32 magic; /* Magic number for detect library misuse */
10539 u32 wsFlags; /* WHERE_* flags that describe the strategy */
10540 u32 nEq; /* Number of == constraints */
10799 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
10878 u32 oldmask; /* Mask of old.* columns referenced */
10879 u32 newmask; /* Mask of new.* columns referenced */
11336 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
11337 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);
11338 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32);
11339 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
11341 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
11497 SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
11539 SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8*, const u8**);
11549 SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char*, u32);
11551 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
11571 #define getVarint32(A,B) (u8)((*(A)<(u8)0x80) ? ((B) = (u32)*(A)),1 : sqlite3GetVarint32((A), (u32 *)&(B)))
11572 #define putVarint32(A,B) (u8)(((u32)(B)<(u32)0x80) ? (*(A) = (unsigned char)(B)),1 : sqlite3PutVarint32((A), (B)))
11762 SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
11824 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
11825 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
12627 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
12629 u32 *aType; /* Type values for all entries in the record */
12630 u32 *aOffset; /* Cached offsets to the start of each columns data */
12832 u32 magic; /* Magic number for sanity checking */
12840 u32 cacheCtr; /* VdbeCursor row cache generation counter */
12871 u32 expmask; /* Binding to these vars invalidates VM */
12892 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
12893 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
12894 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
12895 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
15583 u32 prevSize; /* Size of previous chunk in Mem3Block elements */
15584 u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
15587 u32 next; /* Index in mem3.aPool[] of next free chunk */
15588 u32 prev; /* Index in mem3.aPool[] of previous free chunk */
15604 u32 nPool;
15620 u32 mnMaster;
15628 u32 iMaster;
15629 u32 szMaster;
15636 u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
15637 u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
15646 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
15647 u32 next = mem3.aPool[i].u.list.next;
15648 u32 prev = mem3.aPool[i].u.list.prev;
15666 static void memsys3Unlink(u32 i){
15667 u32 size, hash;
15686 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
15700 static void memsys3Link(u32 i){
15701 u32 size, hash;
15751 static void *memsys3Checkout(u32 i, u32 nBlock){
15752 u32 x;
15769 static void *memsys3FromMaster(u32 nBlock){
15781 u32 newi, x;
15814 static void memsys3Merge(u32 *pRoot){
15815 u32 iNext, prev, size, i, x;
15854 u32 i;
15855 u32 nBlock;
15856 u32 toFree;
15938 u32 size, x;
16091 u32 i, j;
16092 u32 size;
16299 u32 currentOut; /* Current checkout, including internal fragmentation */
16300 u32 currentCount; /* Current number of distinct checkouts */
16301 u32 maxOut; /* Maximum instantaneous currentOut */
16302 u32 maxCount; /* Maximum instantaneous currentCount */
16303 u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
16440 if( (u32)nByte>mem5.maxRequest ){
16492 u32 size, iLogsize;
16507 assert( iBlock+size-1<(u32)mem5.nBlock );
18164 u32 nScratchFree;
18504 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
20219 SQLITE_PRIVATE u32 sqlite3Utf8Read(
20472 u32 c;
21251 SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char *p, u32 v){
21284 u32 a,b,s;
21453 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
21454 u32 a,b;
21517 *v = (u32)v64;
21566 *v = (u32)v64;
21589 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
21592 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
21667 u32 magic;
21684 u32 magic;
23243 u32 sharedMask; /* Mask of shared locks held */
23244 u32 exclMask; /* Mask of exclusive locks held */
23658 u32 mask; /* Mask of locks to take or release */
23673 mask = (u32)((1U<<(ofst+n)) - (1U<<ofst));
23680 u32 allMask = 0; /* Mask of locks held by siblings */
23702 u32 allShared = 0; /* Union of locks held by connections other than "p" */
28422 (u32)sStat.st_ino, (u32)sStat.st_dev);
31717 u32 magic; /* Magic number to detect structure corruption. */
34809 #define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
34823 /* Number of u32 values in hash table. */
34824 #define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))
34859 u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */
34860 u32 nSet; /* Number of bits that are set - only valid for aHash
34863 u32 iDivisor; /* Number of bits handled by each apSub[] entry. */
34865 /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */
34869 u32 aHash[BITVEC_NINT]; /* Hash table representation */
34879 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){
34894 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){
34899 u32 bin = i/p->iDivisor;
34909 u32 h = BITVEC_HASH(i++);
34930 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){
34931 u32 h;
34937 u32 bin = i/p->iDivisor;
34974 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
35001 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
35006 u32 bin = i/p->iDivisor;
35017 u32 *aiValues = pBuf;
35023 u32 h = BITVEC_HASH(aiValues[j]-1);
35053 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){
37515 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
37519 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
37988 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
38182 u32 cksumInit; /* Quasi-random value added to every checksum */
38183 u32 nSubRec; /* Number of records written to sub-journal */
38200 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
38201 u32 sectorSize; /* Assumed sector size during rollback */
38555 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
38574 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
38680 static u32 pager_datahash(int nByte, unsigned char *pData){
38681 u32 hash = 0;
38688 static u32 pager_pagehash(PgHdr *pPage){
38739 static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
38741 u32 len; /* Length in bytes of master journal name */
38743 u32 cksum; /* MJ checksum value read from journal */
38744 u32 u; /* Unsigned loop counter */
38877 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
38878 u32 nWrite; /* Bytes of header sector written */
38996 u32 *pNRec, /* OUT: Value read from the nRec field */
38997 u32 *pDbSize /* OUT: Value of original database size field */
39042 u32 iPageSize; /* Page-size field of journal header */
39043 u32 iSectorSize; /* Sector-size field of journal header */
39122 u32 cksum = 0; /* Checksum of string zMaster */
39570 static u32 pager_cksum(Pager *pPager, const u8 *aData){
39571 u32 cksum = pPager->cksumInit; /* Checksum value to return */
39642 u32 cksum; /* Checksum used for sanity checking */
40133 u32 nRec; /* Number of Records in the journal */
40134 u32 u; /* Unsigned loop counter */
40399 u32 change_counter;
40777 u32 ii; /* Loop counter */
40778 u32 nJRec = 0; /* Number of Journal Records */
40779 u32 dummy;
40791 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
40805 u32 ii; /* Loop counter */
41004 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
41017 u32 pageSize = *pPageSize;
41021 && pageSize && pageSize!=(u32)pPager->pageSize
41838 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
41980 szPageDflt = (u32)pPager->sectorSize;
42879 u32 cksum;
44670 u32 iVersion; /* Wal-index version */
44671 u32 unused; /* Unused (padding) field */
44672 u32 iChange; /* Counter incremented each transaction */
44676 u32 mxFrame; /* Index of last valid frame in the WAL */
44677 u32 nPage; /* Size of database in pages */
44678 u32 aFrameCksum[2]; /* Checksum of last frame in log */
44679 u32 aSalt[2]; /* Two salt values copied from WAL header */
44680 u32 aCksum[2]; /* Checksum over all prior fields */
44733 u32 nBackfill; /* Number of WAL frames backfilled into DB */
44734 u32 aReadMark[WAL_NREADER]; /* Reader marks */
44783 u32 iCallback; /* Value to pass to log callback (or 0) */
44786 volatile u32 **apWiData; /* Pointer to wal-index content in memory */
44787 u32 szPage; /* Database page size */
44795 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
44842 u32 *aPgno; /* Array of page numbers. */
44865 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
44869 sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
44881 static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
44886 int nByte = sizeof(u32*)*(iPage+1);
44887 volatile u32 **apNew;
44888 apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
44894 sizeof(u32*)*(iPage+1-pWal->nWiData));
44902 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
44937 ** The argument to this macro must be of type u32. On a little-endian
44938 ** architecture, it returns the u32 value that results from interpreting
44961 const u32 *aIn, /* Initial checksum value input */
44962 u32 *aOut /* OUT: Final checksum value output */
44964 u32 s1, s2;
44965 u32 *aData = (u32 *)a;
44966 u32 *aEnd = (u32 *)&a[nByte];
45034 u32 iPage, /* Database page number for frame */
45035 u32 nTruncate, /* New db size (or 0 for non-commit frames) */
45040 u32 *aCksum = pWal->hdr.aFrameCksum;
45061 u32 *piPage, /* OUT: Database page number for frame */
45062 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
45067 u32 *aCksum = pWal->hdr.aFrameCksum;
45068 u32 pgno; /* Page number of the frame */
45177 static int walHash(u32 iPage){
45204 volatile u32 **paPgno, /* OUT: Pointer to page number array */
45205 u32 *piZero /* OUT: Frame associated with *paPgno[0] */
45208 volatile u32 *aPgno;
45214 u32 iZero;
45219 aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
45238 static int walFramePage(u32 iFrame){
45252 static u32 walFramePgno(Wal *pWal, u32 iFrame){
45255 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
45274 volatile u32 *aPgno = 0; /* Page number array for hash table */
45275 u32 iZero = 0; /* frame == (aHash[x]+iZero) */
45334 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
45336 u32 iZero = 0; /* One less than frame number of aPgno[1] */
45337 volatile u32 *aPgno = 0; /* Page number array */
45426 u32 aFrameCksum[2] = {0, 0};
45463 u32 magic; /* Magic value read from WAL header */
45464 u32 version; /* Magic value read from WAL header */
45521 u32 pgno; /* Database page number for frame */
45522 u32 nTruncate; /* dbsize field from frame header */
45692 u32 *piPage, /* OUT: The page number of the next page */
45693 u32 *piFrame /* OUT: Wal frame index of next page */
45695 u32 iMin; /* Result pgno must be greater than iMin */
45696 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
45704 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
45744 const u32 *aContent, /* Pages in wal - keys for the sort */
45801 const u32 *aContent, /* Pages in wal */
45878 u32 iLast; /* Last frame in log */
45914 u32 iZero;
45915 volatile u32 *aPgno;
45927 nEntry = (int)((u32*)aHash - (u32*)aPgno);
45935 walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);
45939 p->aSegment[i].aPgno = (u32 *)aPgno;
46021 u32 iDbpage = 0; /* Next database page to write */
46022 u32 iFrame = 0; /* Wal frame containing data for iDbpage */
46023 u32 mxSafeFrame; /* Max frame that can be backfilled */
46024 u32 mxPage; /* Max database page to write */
46052 u32 y = pInfo->aReadMark[i];
46072 u32 nBackfill = pInfo->nBackfill;
46219 u32 aCksum[2]; /* Checksum on the header content */
46279 volatile u32 *page0; /* Chunk of wal-index containing header */
46395 u32 mxReadMark; /* Largest aReadMark[] value */
46501 u32 thisMark = pInfo->aReadMark[i];
46623 u32 iRead = 0; /* If !=0, WAL frame to return data from */
46624 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
46668 volatile u32 *aPgno; /* Pointer to array of page numbers */
46669 u32 iZero; /* Frame number corresponding to aPgno[0] */
46680 u32 iFrame = aHash[iKey] + iZero;
46696 u32 iRead2 = 0;
46697 u32 iTest;
46846 ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
46851 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
46862 ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated
46865 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
46910 u32 salt1;
46925 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
46985 u32 iFrame; /* Next frame address */
47015 u32 aCksum[2]; /* Checksum for wal-header */
47042 u32 nDbsize; /* Db-size field for frame header */
47243 u32 ret = 0;
47765 u32 pageSize; /* Total number of bytes on a page */
47766 u32 usableSize; /* Number of usable bytes on each page */
47768 u32 nPage; /* Number of pages in the database */
47793 u32 nData; /* Number of bytes of data */
47794 u32 nPayload; /* Total amount of payload */
49162 u32 nPayload; /* Number of bytes of cell payload */
49240 u32 nSize;
49280 nSize += (u32)(pIter - pCell);
49845 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){
50082 assert( sizeof(u32)==4 );
50437 pBt->pageSize = (u32)pageSize;
50578 u32 pageSize;
50579 u32 usableSize;
50639 if( (u32)pageSize!=pBt->pageSize ){
51949 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
52095 u32 offset, /* Begin reading this far into payload */
52096 u32 amt, /* Read this many bytes */
52102 u32 nKey;
52138 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
52237 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
52254 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
52300 u32 nKey;
52301 u32 nLocal;
52374 static int moveToChild(BtCursor *pCur, u32 newPgno){
52752 u32 dummy;
53031 u32 n; /* Number of pages on the freelist */
53032 u32 k; /* Number of leaves on the trunk of the freelist */
53112 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
53179 u32 closest;
53183 u32 i;
53354 u32 nLeaf; /* Initial number of leaf cells on trunk page */
53364 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
53368 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
53438 u32 ovflPageSize;
53548 assert( info.nData==(u32)(nData+nZero) );
53665 u32 pc; /* Offset to cell content of cell being deleted */
53684 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
54694 u32 key = get4byte(&apNew[i]->aData[8]);
55571 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
55595 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
55924 u32 sz;
56040 u32 size = 65536;
56360 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
56475 u32 iDestSchema; /* Original schema cookie in destination */
56701 u32 newPgsz = nSrcPgsz;
58838 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
58840 if( ((u32)p->nOp)>addr ){
58849 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
58851 if( ((u32)p->nOp)>addr ){
58859 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
58861 if( ((u32)p->nOp)>addr ){
60134 u32 iRandom;
60724 if( (i>31 || !(mask&(((u32)1)<<i))) && pAux->pAux ){
60868 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
60881 return 8+(u32)i;
60912 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
60959 u32 i[2];
60961 u32 t;
60992 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
60993 u32 serial_type = sqlite3VdbeSerialType(pMem, file_format);
60994 u32 len;
60999 u32 i;
61008 assert( len<=(u32)nBuf );
61026 if( len > (u32)nBuf ){
61027 len = (u32)nBuf;
61042 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
61044 u32 serial_type, /* Serial type to deserialize */
61076 u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
61085 u32 y;
61120 u32 len = (serial_type-12)/2;
61193 u32 idx; /* Offset in aKey[] to read from */
61195 u32 szHdr;
61204 u32 serial_type;
61250 u32 idx1; /* Offset into aKey[] of next header element */
61251 u32 szHdr1; /* Number of bytes in header */
61281 u32 serial_type1;
61357 u32 szHdr; /* Size of the header */
61358 u32 typeRowid; /* Serial type of the rowid */
61359 u32 lenRowid; /* Size of the rowid */
61404 testcase( (u32)m.n==szHdr+lenRowid );
61405 if( unlikely((u32)m.n<szHdr+lenRowid) ){
61541 v->expmask |= ((u32)1 << (iVar-1));
62566 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
63233 2*nField*sizeof(u32);
63246 pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
63250 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
63746 u32 payloadSize; /* Number of bytes in the record */
63753 u32 *aType; /* aType[i] holds the numeric type of the i-th column */
63754 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
63763 u32 offset; /* Offset into the data */
63764 u32 szField; /* Number of bytes in the content of a field */
63767 u32 t; /* A type code from the record header */
63782 u32 serial_type; /* Type field */
63913 u32 n;
65656 u32 payloadSize; /* Number of bytes in the record */
65663 u32 *aType; /* aType[i] holds the numeric type of the i-th column */
65664 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
65673 u32 offset; /* Offset into the data */
65674 u32 szField; /* Number of bytes in the content of a field */
65677 u32 t; /* A type code from the record header */
65727 u.am.payloadSize = (u32)u.am.payloadSize64;
65753 if( u.am.payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
65788 if( u.am.payloadSize <= (u32)u.am.avail ){
66000 u32 serial_type; /* Type field */
66475 sqlite3BtreeGetMeta(db->aDb[u.at.iDb].pBt, u.at.iCookie, (u32 *)&u.at.iMeta);
66551 sqlite3BtreeGetMeta(u.av.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.av.iMeta);
67750 u32 n;
67787 u.bk.n = (u32)u.bk.n64;
67791 if( u.bk.n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
69874 u32 type = v->apCsr[0]->aType[p->iCol];
70169 int (*xCall)(BtCursor*, u32, u32, void*)
72065 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
72069 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73580 u32 n = sqlite3Strlen30(z);
73771 u32 staticFlag = 0;
80162 u32 h = 0;
83904 u32 mask; /* Mask of OLD.* columns in use */
84606 u32 esc /* The escape character */
84608 u32 c, c2;
84662 u32 prior_c = 0;
84738 u32 escape = 0;
86512 #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))
86518 SQLITE_PRIVATE u32 sqlite3FkOldmask(
86522 u32 mask = 0;
91736 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
91959 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
98228 SQLITE_PRIVATE u32 sqlite3TriggerColmask(
98238 u32 mask = 0;
98654 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
99205 u32 meta;
100925 u32 op, /* Mask of WO_xx values describing operator */
102423 assert( (u32)n==pLevel->plan.nEq );
104046 u32 flags = pLevel->plan.wsFlags;
110686 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
114130 typedef unsigned int u32; /* 4-byte unsigned integer */
114260 u32 *aMatchinfo; /* Information about most recent match */
114367 u32 *aMI;
114468 SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
118859 pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32));
118861 memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
118945 u32 *aiOut /* Array to write results into (see above) */
118954 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
118955 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
122894 u32 *pnWord /* OUT: Number of tokens inserted */
123008 static int fts3InsertTerms(Fts3Table *p, sqlite3_value **apVal, u32 *aSz){
123120 u32 *aSz /* Sizes of deleted document written here */
125013 u32 *a, /* The integer values */
125029 u32 *a, /* Write the integer values */
125039 a[i] = (u32)(x & 0xffffffff);
125051 u32 *aSz /* Sizes of each column */
125095 u32 *aSzIns, /* Size increases */
125096 u32 *aSzDel, /* Size decreases */
125101 u32 *a; /* Array of integers that becomes the BLOB */
125109 a = sqlite3_malloc( (sizeof(u32)+10)*nStat );
125126 memset(a, 0, sizeof(u32)*(nStat) );
125129 if( nChng<0 && a[0]<(u32)(-nChng) ){
125135 u32 x = a[i+1];
125352 u32 *aSzDel
125392 u32 *aSzIns = 0; /* Sizes of inserted documents */
125393 u32 *aSzDel; /* Sizes of deleted documents */
125620 u32 *aMatchinfo; /* Pre-allocated buffer */
126381 *pnDoc = (u32)nDoc;
126558 pInfo->aMatchinfo[0] = (u32)nDoc;
126571 u32 iVal;
126574 iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc);
126590 pInfo->aMatchinfo[iCol] = (u32)nToken;
126633 ** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32).
126664 int nMatchinfo = 0; /* Number of u32 elements in match-info */
126679 pCsr->aMatchinfo = (u32 *)sqlite3_malloc(sizeof(u32)*nMatchinfo + nArg + 1);
126685 memset(pCsr->aMatchinfo, 0, sizeof(u32)*nMatchinfo);
127023 int n = pCsr->nMatchinfo * sizeof(u32);
127142 typedef unsigned int u32;
127318 u32 magic; /* Always RTREE_GEOMETRY_MAGIC */
127353 u32 i = (
127354 (((u32)p[0]) << 24) +
127355 (((u32)p[1]) << 16) +
127356 (((u32)p[2]) << 8) +
127357 (((u32)p[3]) << 0)
127359 *(u32 *)pCoord = i;
127385 u32 i;
127387 assert( sizeof(u32)==4 );
127388 i = *(u32 *)pCoord;