Lines Matching refs:u32
8982 typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ typedef
9005 typedef u32 tRowcnt; /* 32-bit is the default */
9416 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
9461 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
9462 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
9540 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
9541 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, u32 *pAmt);
9542 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, u32 *pAmt);
9543 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
9544 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
9549 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
9689 u32 cnt; /* Number of times this instruction was executed */
9992 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
9993 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
9994 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
10147 typedef u32 Pgno;
10234 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int);
10289 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager*);
10365 u32 pageHash; /* Hash of page content */
11041 u32 magic; /* Magic number for detect library misuse */
11668 u32 nRef; /* Number of references to this KeyInfo object */
11928 u32 flags; /* Various flags. EP_* See below */
12145 u32 nAlloc; /* Number of entries allocated in a[] below */
12461 u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
12559 u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */
12560 u32 oldmask; /* Mask of old.* columns referenced */
12561 u32 newmask; /* Mask of new.* columns referenced */
12802 u32 szPma; /* Maximum Sorter PMA size */
13066 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
13067 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
13112 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*);
13145 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
13146 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);
13147 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32);
13148 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
13150 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
13331 SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
13373 SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**);
13388 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
13397 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B)))
13399 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\
13629 SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
13680 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*);
13705 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
13706 SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
14597 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
14598 u32 payloadSize; /* Total number of bytes in the record */
14599 u32 szRow; /* Byte available in aRow */
14600 u32 iHdrOffset; /* Offset to next unparsed byte of the header */
14602 u32 *aOffset; /* Pointer to aType[nField] */
14603 u32 aType[1]; /* Type values for all entries in the record */
14681 u32 uTemp; /* Transient storage for serial_type in OP_MakeRecord */
14829 u32 magic; /* Magic number for sanity checking */
14837 u32 cacheCtr; /* VdbeCursor row cache generation counter */
14859 u32 aCounter[5]; /* Counters used by sqlite3_stmt_status() */
14872 u32 expmask; /* Binding to these vars invalidates VM */
14902 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
14903 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
14904 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
14905 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
14940 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
15010 u32 nowValue[10]; /* Current value */
15011 u32 mxValue[10]; /* Maximum value */
17922 u32 prevSize; /* Size of previous chunk in Mem3Block elements */
17923 u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
17926 u32 next; /* Index in mem3.aPool[] of next free chunk */
17927 u32 prev; /* Index in mem3.aPool[] of previous free chunk */
17943 u32 nPool;
17959 u32 mnMaster;
17967 u32 iMaster;
17968 u32 szMaster;
17975 u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
17976 u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
17985 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){ in memsys3UnlinkFromList()
17986 u32 next = mem3.aPool[i].u.list.next; in memsys3UnlinkFromList()
17987 u32 prev = mem3.aPool[i].u.list.prev; in memsys3UnlinkFromList()
18005 static void memsys3Unlink(u32 i){ in memsys3Unlink()
18006 u32 size, hash; in memsys3Unlink()
18025 static void memsys3LinkIntoList(u32 i, u32 *pRoot){ in memsys3LinkIntoList()
18039 static void memsys3Link(u32 i){ in memsys3Link()
18040 u32 size, hash; in memsys3Link()
18090 static void *memsys3Checkout(u32 i, u32 nBlock){ in memsys3Checkout()
18091 u32 x; in memsys3Checkout()
18108 static void *memsys3FromMaster(u32 nBlock){ in memsys3FromMaster()
18120 u32 newi, x; in memsys3FromMaster()
18153 static void memsys3Merge(u32 *pRoot){ in memsys3Merge()
18154 u32 iNext, prev, size, i, x; in memsys3Merge()
18193 u32 i; in memsys3MallocUnsafe()
18194 u32 nBlock; in memsys3MallocUnsafe()
18195 u32 toFree; in memsys3MallocUnsafe()
18277 u32 size, x; in memsys3FreeUnsafe()
18430 u32 i, j; in sqlite3Memsys3Dump()
18431 u32 size; in sqlite3Memsys3Dump()
18638 u32 currentOut; /* Current checkout, including internal fragmentation */
18639 u32 currentCount; /* Current number of distinct checkouts */
18640 u32 maxOut; /* Maximum instantaneous currentOut */
18641 u32 maxCount; /* Maximum instantaneous currentCount */
18642 u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
18760 if( (u32)nByte>mem5.maxRequest ){ in memsys5MallocUnsafe()
18819 u32 size, iLogsize; in memsys5FreeUnsafe()
18834 assert( iBlock+size-1<(u32)mem5.nBlock ); in memsys5FreeUnsafe()
20581 u32 nScratchFree;
20935 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
21519 u32 bFlags, /* SQLITE_PRINTF_* flags */
22486 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){
23060 SQLITE_PRIVATE u32 sqlite3Utf8Read(
23310 u32 c;
24070 u32 u = 0;
24203 u32 a,b,s;
24372 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
24373 u32 a,b;
24436 *v = (u32)v64;
24485 *v = (u32)v64;
24508 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
24512 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
24587 u32 magic;
24604 u32 magic;
29758 (u32)sStat.st_ino, (u32)sStat.st_dev);
33569 u32 magic1; /* Magic number to detect structure corruption. */
33574 u32 magic2; /* Magic number to detect structure corruption. */
38888 #define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
38903 #define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))
38938 u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */
38939 u32 nSet; /* Number of bits that are set - only valid for aHash
38942 u32 iDivisor; /* Number of bits handled by each apSub[] entry. */
38948 u32 aHash[BITVEC_NINT]; /* Hash table representation */
38958 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){
38973 SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){
38978 u32 bin = i/p->iDivisor;
38988 u32 h = BITVEC_HASH(i++);
39009 SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){
39010 u32 h;
39016 u32 bin = i/p->iDivisor;
39053 u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
39080 SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
39085 u32 bin = i/p->iDivisor;
39096 u32 *aiValues = pBuf;
39102 u32 h = BITVEC_HASH(aiValues[j]-1);
39132 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){
41587 SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
41588 SQLITE_PRIVATE int sqlite3WalReadFrame(Wal *, u32, int, u8 *);
41602 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
41606 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
42082 u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
42287 u32 cksumInit; /* Quasi-random value added to every checksum */
42288 u32 nSubRec; /* Number of records written to sub-journal */
42298 u32 iDataVersion; /* Changes whenever database content changes */
42310 u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
42311 u32 sectorSize; /* Assumed sector size during rollback */
42685 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
42704 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
42810 static u32 pager_datahash(int nByte, unsigned char *pData){
42811 u32 hash = 0;
42818 static u32 pager_pagehash(PgHdr *pPage){
42869 static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
42871 u32 len; /* Length in bytes of master journal name */
42873 u32 cksum; /* MJ checksum value read from journal */
42874 u32 u; /* Unsigned loop counter */
43008 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
43009 u32 nWrite; /* Bytes of header sector written */
43127 u32 *pNRec, /* OUT: Value read from the nRec field */
43128 u32 *pDbSize /* OUT: Value of original database size field */
43173 u32 iPageSize; /* Page-size field of journal header */
43174 u32 iSectorSize; /* Sector-size field of journal header */
43253 u32 cksum = 0; /* Checksum of string zMaster */
43324 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){
43721 static u32 pager_cksum(Pager *pPager, const u8 *aData){
43722 u32 cksum = pPager->cksumInit; /* Checksum value to return */
43793 u32 cksum; /* Checksum used for sanity checking */
44304 u32 nRec; /* Number of Records in the journal */
44305 u32 u; /* Unsigned loop counter */
44509 static int readDbPage(PgHdr *pPg, u32 iFrame){
44572 u32 change_counter;
44609 u32 iFrame = 0;
44959 u32 ii; /* Loop counter */
44960 u32 nJRec = 0; /* Number of Journal Records */
44961 u32 dummy;
44973 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
44987 u32 ii; /* Loop counter */
45234 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
45247 u32 pageSize = *pPageSize;
45251 && pageSize && pageSize!=(u32)pPager->pageSize
46171 u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
46321 szPageDflt = (u32)pPager->sectorSize;
46907 u32 iFrame = 0; /* Frame to read from WAL file */
47340 u32 cksum;
47525 if( pPg->pPager->sectorSize > (u32)pPg->pPager->pageSize ){
49204 u32 iVersion; /* Wal-index version */
49205 u32 unused; /* Unused (padding) field */
49206 u32 iChange; /* Counter incremented each transaction */
49210 u32 mxFrame; /* Index of last valid frame in the WAL */
49211 u32 nPage; /* Size of database in pages */
49212 u32 aFrameCksum[2]; /* Checksum of last frame in log */
49213 u32 aSalt[2]; /* Two salt values copied from WAL header */
49214 u32 aCksum[2]; /* Checksum over all prior fields */
49267 u32 nBackfill; /* Number of WAL frames backfilled into DB */
49268 u32 aReadMark[WAL_NREADER]; /* Reader marks */
49317 u32 iCallback; /* Value to pass to log callback (or 0) */
49321 volatile u32 **apWiData; /* Pointer to wal-index content in memory */
49322 u32 szPage; /* Database page size */
49334 u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
49381 u32 *aPgno; /* Array of page numbers. */
49404 #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
49408 sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
49420 static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
49425 int nByte = sizeof(u32*)*(iPage+1);
49426 volatile u32 **apNew;
49427 apNew = (volatile u32 **)sqlite3_realloc64((void *)pWal->apWiData, nByte);
49433 sizeof(u32*)*(iPage+1-pWal->nWiData));
49441 pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
49500 const u32 *aIn, /* Initial checksum value input */
49501 u32 *aOut /* OUT: Final checksum value output */
49503 u32 s1, s2;
49504 u32 *aData = (u32 *)a;
49505 u32 *aEnd = (u32 *)&a[nByte];
49573 u32 iPage, /* Database page number for frame */
49574 u32 nTruncate, /* New db size (or 0 for non-commit frames) */
49579 u32 *aCksum = pWal->hdr.aFrameCksum;
49600 u32 *piPage, /* OUT: Database page number for frame */
49601 u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
49606 u32 *aCksum = pWal->hdr.aFrameCksum;
49607 u32 pgno; /* Page number of the frame */
49717 static int walHash(u32 iPage){
49744 volatile u32 **paPgno, /* OUT: Pointer to page number array */
49745 u32 *piZero /* OUT: Frame associated with *paPgno[0] */
49748 volatile u32 *aPgno;
49754 u32 iZero;
49759 aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
49778 static int walFramePage(u32 iFrame){
49792 static u32 walFramePgno(Wal *pWal, u32 iFrame){
49795 return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
49814 volatile u32 *aPgno = 0; /* Page number array for hash table */
49815 u32 iZero = 0; /* frame == (aHash[x]+iZero) */
49874 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
49876 u32 iZero = 0; /* One less than frame number of aPgno[1] */
49877 volatile u32 *aPgno = 0; /* Page number array */
49966 u32 aFrameCksum[2] = {0, 0};
50003 u32 magic; /* Magic value read from WAL header */
50004 u32 version; /* Magic value read from WAL header */
50062 u32 pgno; /* Database page number for frame */
50063 u32 nTruncate; /* dbsize field from frame header */
50242 u32 *piPage, /* OUT: The page number of the next page */
50243 u32 *piFrame /* OUT: Wal frame index of next page */
50245 u32 iMin; /* Result pgno must be greater than iMin */
50246 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
50254 u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
50294 const u32 *aContent, /* Pages in wal - keys for the sort */
50351 const u32 *aContent, /* Pages in wal */
50428 u32 iLast; /* Last frame in log */
50464 u32 iZero;
50465 volatile u32 *aPgno;
50477 nEntry = (int)((u32*)aHash - (u32*)aPgno);
50485 walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);
50489 p->aSegment[i].aPgno = (u32 *)aPgno;
50546 static void walRestartHdr(Wal *pWal, u32 salt1){
50549 u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
50603 u32 iDbpage = 0; /* Next database page to write */
50604 u32 iFrame = 0; /* Wal frame containing data for iDbpage */
50605 u32 mxSafeFrame; /* Max frame that can be backfilled */
50606 u32 mxPage; /* Max database page to write */
50643 u32 y = pInfo->aReadMark[i];
50663 u32 nBackfill = pInfo->nBackfill;
50735 u32 salt1;
50868 u32 aCksum[2]; /* Checksum on the header content */
50928 volatile u32 *page0; /* Chunk of wal-index containing header */
51044 u32 mxReadMark; /* Largest aReadMark[] value */
51150 u32 thisMark = pInfo->aReadMark[i];
51268 u32 *piRead /* OUT: Frame number (or zero) */
51270 u32 iRead = 0; /* If !=0, WAL frame to return data from */
51271 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
51315 volatile u32 *aPgno; /* Pointer to array of page numbers */
51316 u32 iZero; /* Frame number corresponding to aPgno[0] */
51327 u32 iFrame = aHash[iKey] + iZero;
51343 u32 iRead2 = 0;
51344 u32 iTest;
51366 u32 iRead, /* Frame to read */
51503 SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
51517 SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
51562 u32 salt1;
51677 u32 iFrame; /* Next frame address */
51713 u32 aCksum[2]; /* Checksum for wal-header */
51970 u32 ret = 0;
52436 u32 iDataVersion; /* Combines with pBt->pPager->iDataVersion */
52511 u32 pageSize; /* Total number of bytes on a page */
52512 u32 usableSize; /* Number of usable bytes on each page */
52514 u32 nPage; /* Number of pages in the database */
52548 u32 nPayload; /* Bytes of payload */
54045 u32 nPayload; /* Number of bytes of cell payload */
54123 u32 nSize; /* Size value to return */
54159 nSize += (u32)(pIter - pCell);
54464 u32 iLast = pPage->pBt->usableSize-4; /* Largest possible freeblock offset */
54465 u32 iEnd = iStart + iSize; /* First byte past the iStart buffer */
54834 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){
55083 assert( sizeof(u32)==4 );
55484 pBt->pageSize = (u32)pageSize;
55650 u32 pageSize;
55651 u32 usableSize;
55727 if( (u32)pageSize!=pBt->pageSize ){
57092 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
57243 u32 offset, /* Begin reading this far into payload */
57244 u32 amt, /* Read this many bytes */
57292 const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
57445 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
57462 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
57503 u32 *pAmt /* Write the number of available bytes here */
57505 u32 amt;
57535 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){
57538 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
57552 static int moveToChild(BtCursor *pCur, u32 newPgno){
58320 u32 n; /* Number of pages on the freelist */
58321 u32 k; /* Number of leaves on the trunk of the freelist */
58417 }else if( k>(u32)(pBt->usableSize/4 - 2) ){
58486 u32 closest;
58490 u32 i;
58692 u32 nLeaf; /* Initial number of leaf cells on trunk page */
58702 if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
58706 if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
58787 u32 ovflPageSize;
59048 u32 pc; /* Offset to cell content of cell being deleted */
59066 if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
60341 u32 key = get4byte(&apNew[i]->aData[8]);
61272 SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
61302 SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
61604 static void btreeHeapInsert(u32 *aHeap, u32 x){
61605 u32 j, i = ++aHeap[0];
61614 static int btreeHeapPull(u32 *aHeap, u32 *pOut){
61615 u32 j, i, x;
61665 u32 *heap = 0;
61666 u32 x, prev = 0;
61705 u32 sz;
61811 heap = (u32*)sqlite3PageMalloc( pBt->pageSize );
61830 u32 size = 65536;
62180 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
62322 u32 iDestSchema; /* Original schema cookie in destination */
62580 u32 newPgsz = nSrcPgsz;
64038 u32 offset, /* Offset from the start of data to return bytes from. */
64039 u32 amt, /* Number of bytes to return. */
64044 u32 available = 0; /* Number of bytes available on the local btree page */
64692 u32 t; /* a column type code */
65419 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
65421 if( ((u32)p->nOp)>addr ){
65430 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
65432 if( ((u32)p->nOp)>addr ){
65440 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
65442 if( ((u32)p->nOp)>addr ){
66835 u32 iRandom;
67665 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
67667 u32 n;
67683 return ((i&1)==i && file_format>=4) ? 8+(u32)u : 1;
67696 n = (u32)pMem->n;
67706 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
67753 u32 i[2];
67755 u32 t;
67781 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
67782 u32 len;
67787 u32 i;
67823 #define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
67835 static u32 SQLITE_NOINLINE serialGet(
67837 u32 serial_type, /* Serial type to deserialize */
67841 u32 y = FOUR_BYTE_UINT(buf+4);
67871 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
67873 u32 serial_type, /* Serial type to deserialize */
68011 u32 idx; /* Offset in aKey[] to read from */
68013 u32 szHdr;
68022 u32 serial_type;
68054 u32 d1; /* Offset into aKey[] of next data element */
68055 u32 idx1; /* Offset into aKey[] of next header element */
68056 u32 szHdr1; /* Number of bytes in header */
68086 u32 serial_type1;
68097 if( d1+serial_type1+2>(u32)nKey1
68098 && d1+sqlite3VdbeSerialTypeLen(serial_type1)>(u32)nKey1
68158 u32 szHdr;
68159 u32 idx;
68160 u32 notUsed;
68166 assert( szHdr<=(u32)nKey );
68322 static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){
68323 u32 y;
68382 u32 d1; /* Offset into aKey[] of next data element */
68384 u32 szHdr1; /* Size of record header in bytes */
68385 u32 idx1; /* Offset of first type in header */
68396 u32 s1;
68419 u32 serial_type;
68583 u32 y;
68776 u32 szHdr; /* Size of the header */
68777 u32 typeRowid; /* Serial type of the rowid */
68778 u32 lenRowid; /* Size of the rowid */
68793 rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
68821 testcase( (u32)m.n==szHdr+lenRowid );
68822 if( unlikely((u32)m.n<szHdr+lenRowid) ){
68872 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m);
68957 v->expmask |= ((u32)1 << (iVar-1));
70149 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
70474 u32 v;
70947 ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
70963 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
73134 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
73142 u32 offset; /* Offset into the data */
73143 u32 szField; /* Number of bytes in the content of a field */
73144 u32 avail; /* Number of bytes of available data */
73145 u32 t; /* A type code from the record header */
73192 pC->payloadSize = (u32)payloadSize64;
73200 if( pC->payloadSize <= (u32)avail ){
73205 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
73291 pC->iHdrOffset = (u32)(zHdr - zData);
73439 u32 serial_type; /* Type field */
73934 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
73990 sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
74114 if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
75213 u32 n;
75252 n = (u32)n64;
75256 if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
77490 u32 type = pC->aType[p->iCol];
77791 int (*xCall)(BtCursor*, u32, u32, void*)
78888 u32 szPma = sqlite3GlobalConfig.szPma;
81669 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
81673 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
83468 u32 n = sqlite3Strlen30(z);
83662 u32 staticFlag = 0;
84052 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){
84054 u32 m = 0;
84483 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, u32 inFlags, int *prRhsHasNull){
84587 u32 savedNQueryLoop = pParse->nQueryLoop;
85630 u32 constMask = 0; /* Mask of function arguments that are constant */
86793 u32 combinedFlags;
88337 u32 nRowid; /* Sizeof aRowid[] */
88340 u32 iHash; /* Tiebreaker hash */
88350 u32 iPrn; /* Pseudo-random number used for sampling */
88512 p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]);
91945 u32 h = 0;
94354 if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
96209 u32 mask; /* Mask of OLD.* columns in use */
97062 u32 esc /* The escape character */
97064 u32 c, c2; /* Next pattern and input string chars */
97065 u32 matchOne = pInfo->matchOne; /* "?" or "_" */
97066 u32 matchAll = pInfo->matchAll; /* "*" or "%" */
97067 u32 matchOther; /* "[" or the escape character */
97117 u32 cx;
97142 u32 prior_c = 0;
97221 u32 escape = 0;
99271 #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))
99277 SQLITE_PRIVATE u32 sqlite3FkOldmask(
99281 u32 mask = 0;
102978 u32 nExt; /* Number of entries in aExt[] */
103011 u32 i;
103093 u32 i;
103213 u32 iArg; /* Extra argument */
105823 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
106056 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
112107 u32 nAlloc; /* Slots allocated for azResult[] */
112108 u32 nRow; /* Number of rows in the result */
112109 u32 nColumn; /* Number of columns in the result */
112110 u32 nData; /* Slots used in azResult[]. (nRow+1)*nColumn */
113367 SQLITE_PRIVATE u32 sqlite3TriggerColmask(
113377 u32 mask = 0;
113868 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
114475 u32 meta;
115854 u32 wsFlags; /* WHERE_* flags describing the plan */
116016 u32 opMask; /* Acceptable operators */
116707 u32 opMask, /* Operator(s) to scan for */
116762 u32 op, /* Mask of WO_xx values describing operator */
117989 assert( (u32)n==pLoop->u.btree.nEq );
118688 (u32)iLower, (u32)iUpper, nOut));
119267 u32 flags; /* Flags that describe this loop */
120881 u32 saved_wsFlags; /* Original value of pNew->wsFlags */
128744 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
132829 typedef unsigned int u32; /* 4-byte unsigned integer */
132896 u32 nLeafAdd; /* Number of leaf blocks added this trans */
132986 u32 *aMatchinfo; /* Information about most recent match */
133108 u32 *aMI;
133226 SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
133347 u32 a;
133371 u32 a;
133384 *pi = (int)(a | ((u32)(*p & 0x0F) << 28));
136363 const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */
138597 pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32));
138599 memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
138683 u32 *aiOut /* Array to write results into (see above) */
138692 aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
138693 aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
143747 u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */
143874 u32 *aSz
144018 u32 *aSz, /* Sizes of deleted document written here */
146244 u32 *a, /* The integer values */
146260 u32 *a, /* Write the integer values */
146270 a[i] = (u32)(x & 0xffffffff);
146282 u32 *aSz /* Sizes of each column, in tokens */
146326 u32 *aSzIns, /* Size increases */
146327 u32 *aSzDel, /* Size decreases */
146332 u32 *a; /* Array of integers that becomes the BLOB */
146340 a = sqlite3_malloc( (sizeof(u32)+10)*nStat );
146358 memset(a, 0, sizeof(u32)*(nStat) );
146366 if( nChng<0 && a[0]<(u32)(-nChng) ){
146372 u32 x = a[i+1];
146444 u32 *aSz = 0;
146445 u32 *aSzIns = 0;
146446 u32 *aSzDel = 0;
146460 int nByte = sizeof(u32) * (p->nColumn+1)*3;
146461 aSz = (u32 *)sqlite3_malloc(nByte);
148415 u32 *aSzDel
148431 memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2);
148469 u32 *aSzIns = 0; /* Sizes of inserted documents */
148470 u32 *aSzDel = 0; /* Sizes of deleted documents */
148717 u32 *aMatchinfo; /* Pre-allocated buffer */
149457 memset(&p->aMatchinfo[iStart], 0, sizeof(u32) * p->nCol);
149471 p->aMatchinfo[iStart + iCol] = (u32)nHit;
149552 *pnDoc = (u32)nDoc;
149731 pInfo->aMatchinfo[0] = (u32)nDoc;
149744 u32 iVal;
149747 iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc);
149763 pInfo->aMatchinfo[iCol] = (u32)nToken;
149856 pCsr->aMatchinfo = (u32 *)sqlite3_malloc(sizeof(u32)*nMatchinfo + nArg + 1);
149862 memset(pCsr->aMatchinfo, 0, sizeof(u32)*nMatchinfo);
150202 int n = pCsr->nMatchinfo * sizeof(u32);
151043 typedef unsigned int u32;
151205 u32 anQueue[RTREE_MAX_DEPTH+1]; /* Number of queued entries by iLevel */
151218 u32 u; /* Unsigned for byte-order conversions */
151321 u32 magic; /* Always RTREE_GEOMETRY_MAGIC */
151343 (((u32)p[0]) << 24) +
151344 (((u32)p[1]) << 16) +
151345 (((u32)p[2]) << 8) +
151346 (((u32)p[3]) << 0)
151373 u32 i;
151375 assert( sizeof(u32)==4 );
151908 c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16) \
151909 +((u32)a[2]<<8) + a[3]; \
152542 memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
155293 u32 iChildPg; /* Child node (or 0 if this is a leaf) */
155295 u32 *aOvfl; /* Array of overflow page numbers */
155301 u32 iPgno;
155312 u32 iRightChildPg; /* Right-child page number (or 0) */
155327 u32 iPageno; /* Value of 'pageno' column */
155569 u32 nPayload; /* Bytes of payload total (local+overflow) */
155576 if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
155580 assert( nPayload>=(u32)nLocal );
155582 if( nPayload>(u32)nLocal ){
155587 pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
155592 u32 iPrev = pCell->aOvfl[j-1];
155656 u32 iRoot = (u32)sqlite3_column_int64(pCsr->pStmt, 1);
