Lines Matching defs:pgno
16837 typedef u32 Pgno;
16857 #define PAGER_SJ_PGNO_COMPUTED(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
16952 SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager*, Pgno);
16967 SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
16968 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
16977 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
17018 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno);
17044 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
17046 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage*, Pgno, u16);
17050 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
17146 SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree*,Pgno);
17147 SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree*);
17159 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, Pgno*, int flags);
17308 Pgno iTable, /* Index of root page */
17409 Pgno *aRoot, /* An array of root pages numbers for individual trees */
18218 PgHdr *pDirty; /* Transient list of dirty sorted by pgno */
18223 Pgno pgno; /* Page number for this page */
18282 SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch(PCache*, Pgno, int createFlag);
18283 SQLITE_PRIVATE int sqlite3PcacheFetchStress(PCache*, Pgno, sqlite3_pcache_page**);
18284 SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno, sqlite3_pcache_page *pPage);
18294 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
18296 /* Remove all pages with pgno>x. Reset the cache if x==0 */
18297 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
18724 Pgno newTnum; /* Rootpage of table being initialized */
19455 Pgno tnum; /* Root BTree page for this table */
19825 Pgno tnum; /* DB Page containing root of this index */
21267 Pgno mxPage; /* Maximum page number. 0 for no limit. */
21669 SQLITE_PRIVATE int sqlite3CorruptPgnoError(int,Pgno);
22473 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, Pgno, Pgno);
22567 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
22605 SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, Pgno, u8, const char *);
24393 Pgno pgnoRoot; /* Root page of the open btree cursor */
39700 unsigned int pgno;
39715 pgno = 1 + iOfst/iAmt;
39717 pgno = 1;
39719 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
39786 unsigned int pgno;
39795 pgno = 1 + iOfst/iAmt;
39796 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
39827 unsigned int pgno, pgnoMax;
39829 pgno = 1 + size/pFile->szPage;
39831 while( pgno<=pgnoMax ){
39832 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
39834 pgno++;
56076 int pgno;
56077 for(pgno=1; pgno<=nPage; pgno++){
56079 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
56080 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
56797 # define pcachePageTrace(PGNO, X)
56838 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
56895 pPage->pgno));
56962 pcacheTrace(("%p.UNPIN %d\n", p->pCache, p->pgno));
57100 Pgno pgno, /* Page number to obtain */
57122 pRes = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
57123 pcacheTrace(("%p.FETCH %d%s (result: %p) ",pCache,pgno,
57125 pcachePageTrace(pgno, pRes);
57142 Pgno pgno, /* Page number to obtain */
57171 pPg->pgno, pgno,
57175 pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
57183 *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
57198 Pgno pgno, /* Page number obtained */
57212 pPgHdr->pgno = pgno;
57214 return sqlite3PcacheFetchFinish(pCache,pgno,pPage);
57225 Pgno pgno, /* Page number obtained */
57234 return pcacheFetchFinishWithInit(pCache, pgno, pPage);
57295 pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno));
57315 pcacheTrace(("%p.CLEAN %d\n",p->pCache,p->pgno));
57359 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
57365 pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
57374 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
57375 p->pgno = newPgno;
57383 ** Drop every cache entry whose page number is greater than "pgno". The
57385 ** other than page 1 with a page number greater than pgno.
57387 ** If there is a reference to page 1 and the pgno parameter passed to this
57391 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
57395 pcacheTrace(("%p.TRUNCATE %d\n",pCache,pgno));
57398 /* This routine never gets call with a positive pgno except right
57400 ** it must be that pgno==0.
57402 assert( p->pgno>0 );
57403 if( p->pgno>pgno ){
57408 if( pgno==0 && pCache->nRefSum ){
57414 pgno = 1;
57417 sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
57438 ** Merge two lists of pages connected by pDirty and in pgno order.
57446 if( pA->pgno<pB->pgno ){
57468 ** Sort the list of pages in ascending order by pgno. Pages are
58280 unsigned int iLimit /* Drop pages with this pgno or larger */
59520 SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
59524 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
59531 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
59542 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
60020 Pgno nOrig; /* Original number of pages in file */
60021 Pgno iSubRec; /* Index of first record in sub-journal */
60236 Pgno dbSize; /* Number of pages in the database */
60237 Pgno dbOrigSize; /* dbSize before the current transaction */
60238 Pgno dbFileSize; /* Number of pages in the database file */
60239 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
60267 Pgno mxPgno; /* Maximum allowed size of the database */
60268 Pgno lckPgno; /* Page number for the locking page */
60280 int (*xGet)(Pager*,Pgno,DbPage**,int); /* Routine to fetch a patch */
60381 ** Return true if page pgno can be read directly from the database file
60389 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
60397 (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
60401 UNUSED_PARAMETER(pgno);
60619 static int getPageNormal(Pager*,Pgno,DbPage**,int);
60620 static int getPageError(Pager*,Pgno,DbPage**,int);
60622 static int getPageMMap(Pager*,Pgno,DbPage**,int);
60653 Pgno pgno = pPg->pgno;
60657 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
60672 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
61389 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
61393 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
61399 if( pgno<=p->nOrig ){
61400 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
61547 static int pager_truncate(Pager *pPager, Pgno nPage);
61880 Pgno pgno; /* The page number of a page in journal */
61910 rc = read32bits(jfd, *pOffset, &pgno);
61921 if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){
61925 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
61939 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
61945 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
61987 pPg = sqlite3PagerLookup(pPager, pgno);
61992 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
62004 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
62016 if( pgno>pPager->dbFileSize ){
62017 pPager->dbFileSize = pgno;
62020 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
62042 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
62067 if( pgno==1 ){
62239 static int pager_truncate(Pager *pPager, Pgno nPage){
62390 Pgno mxPg = 0; /* Size of the original file in pages */
62610 u32 iFrame = 0; /* Frame of WAL containing pgno */
62616 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
62624 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
62631 if( pPg->pgno==1 ){
62653 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
62655 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
62696 static int pagerUndoCallback(void *pCtx, Pgno iPg){
62747 rc = pagerUndoCallback((void *)pPager, pList->pgno);
62766 Pgno nTruncate, /* Database size after this commit */
62778 assert( p->pgno < p->pDirty->pgno );
62791 if( p->pgno<=nTruncate ){
62802 if( pList->pgno==1 ) pager_write_changecounter(pList);
62808 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
62863 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
62864 Pgno nPage; /* Value to return via *pnPage */
62889 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
62897 pPager->mxPgno = (Pgno)nPage;
62935 Pgno nPage; /* Size of the database file */
63394 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
63396 pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1;
63431 SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){
63574 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
63575 Pgno pgno = pPg->pgno;
63579 assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,pgno) );
63601 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
63645 ** Obtain a reference to a memory mapped page object for page number pgno.
63656 Pgno pgno, /* Page number */
63671 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
63687 p->pgno = pgno;
63706 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
63823 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
63824 return pPg->pgno;
64037 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
64045 Pgno pgno = pList->pgno;
64055 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
64056 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
64060 if( pList->pgno==1 ) pager_write_changecounter(pList);
64071 if( pgno==1 ){
64074 if( pgno>pPager->dbFileSize ){
64075 pPager->dbFileSize = pgno;
64080 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
64083 PAGERID(pPager), pgno, pager_pagehash(pList)));
64084 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
64087 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
64122 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
64141 || pPg->pgno>pPager->dbOrigSize
64152 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
64153 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
64162 rc = addToSavepointBitvecs(pPager, pPg->pgno);
64260 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
64749 Pgno nPage; /* Number of pages in database file */
65064 ** page with page number pgno. If the requested reference is
65102 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
65121 Pgno pgno, /* Page number to fetch */
65135 if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
65136 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
65139 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
65146 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
65148 assert( pPg->pgno==pgno );
65155 assert( pgno!=PAGER_SJ_PGNO(pPager) );
65166 if( pgno==PAGER_SJ_PGNO(pPager) ){
65174 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
65175 if( pgno>pPager->mxPgno ){
65177 if( pgno<=pPager->dbSize ){
65191 if( pgno<=pPager->dbOrigSize ){
65192 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
65195 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
65200 IOTRACE(("ZERO %p %d\n", pPager, pgno));
65227 Pgno pgno, /* Page number to fetch */
65239 const int bMmapOk = (pgno>1
65245 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
65246 ** allows the compiler optimizer to reuse the results of the "pgno>1"
65247 ** test in the previous statement, and avoid testing pgno==0 in the
65248 ** common case where pgno is large. */
65249 if( pgno<=1 && pgno==0 ){
65258 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
65267 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
65271 pPg = sqlite3PagerLookup(pPager, pgno);
65274 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
65276 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
65289 return getPageNormal(pPager, pgno, ppPage, flags);
65296 Pgno pgno, /* Page number to fetch */
65300 UNUSED_PARAMETER(pgno);
65312 Pgno pgno, /* Page number to fetch */
65318 printf("PAGE %u\n", pgno);
65320 rc = pPager->xGet(pPager, pgno, ppPage, flags);
65322 printf("PAGE %u failed with 0x%02x\n", pgno, rc);
65328 return pPager->xGet(pPager, pgno, ppPage, flags);
65343 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
65346 assert( pgno!=0 );
65348 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
65351 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
65372 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
65386 assert( pPg->pgno==1 );
65585 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
65600 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
65607 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
65611 PAGERID(pPager), pPg->pgno,
65617 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
65620 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
65674 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
65677 if( pPg->pgno<=pPager->dbOrigSize ){
65687 PAGERID(pPager), pPg->pgno,
65707 if( pPager->dbSize<pPg->pgno ){
65708 pPager->dbSize = pPg->pgno;
65726 Pgno nPageCount; /* Total number of pages in database file */
65727 Pgno pg1; /* First page of the sector pPg is located on. */
65732 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
65746 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
65749 if( pPg->pgno>nPageCount ){
65750 nPage = (pPg->pgno - pg1)+1;
65757 assert(pg1<=pPg->pgno);
65758 assert((pg1+nPage)>pPg->pgno);
65761 Pgno pg = pg1+ii;
65763 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
65823 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
65870 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
65871 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
66249 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
66718 ** Move the page pPg to location pgno in the file.
66721 ** pgno (which we call pPgOld) though that page is allowed to be
66722 ** in cache. If the page previously located at pgno is not already
66742 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
66744 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
66746 Pgno origPgno; /* The original page number */
66777 ** subjournalPage() may need to allocate space to store pPg->pgno into
66788 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
66789 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
66791 /* If the journal needs to be sync()ed before page pPg->pgno can
66792 ** be written to, store pPg->pgno in local variable needSyncPgno.
66795 ** the journal needs to be sync()ed before database page pPg->pgno
66799 needSyncPgno = pPg->pgno;
66801 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
66805 /* If the cache contains a page with page-number pgno, remove it
66807 ** page pgno before the 'move' operation, it needs to be retained
66811 pPgOld = sqlite3PagerLookup(pPager, pgno);
66828 origPgno = pPg->pgno;
66829 sqlite3PcacheMove(pPg, pgno);
66880 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
66881 assert( pPg->pgno!=iNew );
68430 u32 pgno; /* Page number of the frame */
68442 pgno = sqlite3Get4byte(&aFrame[0]);
68443 if( pgno==0 ){
68465 *piPage = pgno;
68919 u32 pgno; /* Database page number for frame */
68925 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
68927 rc = walIndexAppend(pWal, iFrame, pgno);
69184 u32 iMin; /* Result pgno must be greater than iMin */
69249 Pgno dbpage;
70320 u32 pgno; /* Database page number for frame */
70326 if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
70708 u32 pgno; /* Page number in db file */
70715 pgno = sLoc.aPgno[i-sLoc.iZero-1];
70716 iDbOff = (i64)(pgno-1) * szPage;
70933 ** Search the wal file for page pgno. If found, set *piRead to the frame that
70934 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
70942 Pgno pgno, /* Database page number to read data for */
70965 ** pgno. Each iteration of the following for() loop searches one
70982 ** (aPgno[iFrame]==pgno):
71002 iKey = walHash(pgno);
71008 && sLoc.aPgno[(iH-1)&(HASHTABLE_NPAGE-1)]==pgno
71031 if( walFramePgno(pWal, iTest)==pgno ){
71045 ** Search the wal file for page pgno. If found, set *piRead to the frame that
71046 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
71057 Pgno pgno, /* Database page number to read data for */
71062 rc = walFindFrame(pWal, pgno, piRead);
71093 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
71189 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
71192 Pgno iMax = pWal->hdr.mxFrame;
71193 Pgno iFrame;
71388 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
71457 Pgno nTruncate, /* Database size after this commit */
71564 VVA_ONLY(rc =) walFindFrame(pWal, p->pgno, &iWrite);
71653 rc = walIndexAppend(pWal, iFrame, p->pgno);
71659 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
71694 Pgno nTruncate, /* Database size after this commit */
72359 Pgno pgno; /* Page number for this page */
72397 Pgno iTable; /* Root page of table */
72621 Pgno *aOverflow; /* Cache of overflow page locations */
72631 Pgno pgnoRoot; /* The root page of this tree */
72691 #define PENDING_BYTE_PAGE(pBt) ((Pgno)((PENDING_BYTE/((pBt)->pageSize))+1))
72703 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
72704 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
72705 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
72708 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
72709 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
72710 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
72786 Pgno nCkPage; /* Pages in the database. 0 for partial check */
72792 Pgno v0; /* Value for first %u substitution in zPfx (root page) */
72793 Pgno v1; /* Value for second %u substitution in zPfx (current pg) */
73259 p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
73270 # define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)
73339 Pgno iRoot, /* Root page of b-tree */
73344 Pgno iTab = 0;
73428 static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
73448 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
73520 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
73712 Pgno pgnoRoot, /* The table that might be changing */
73736 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
73770 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
73773 assert( pgno<=pBt->nPage );
73779 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
73780 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
73792 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
73794 return p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTestNotNull(p, pgno));
73902 static int SQLITE_NOINLINE saveCursorsOnList(BtCursor*,Pgno,BtCursor*);
73925 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
73944 Pgno iRoot, /* Only save cursor with this iRoot. Save all if zero */
74151 ** Return 0 (not a valid page) for pgno==1 since there is
74155 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
74157 Pgno iPtrMap, ret;
74159 if( pgno<2 ) return 0;
74161 iPtrMap = (pgno-2)/nPagesPerMapPage;
74173 ** so that it maps to type 'eType' and parent page number 'pgno'.
74179 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
74182 Pgno iPtrmap; /* The pointer map page number */
74238 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
74707 Pgno ovfl;
74714 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
75150 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
75223 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
75340 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
75392 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno || CORRUPT_DB );
75423 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
75425 if( pgno!=pPage->pgno ){
75429 pPage->pgno = pgno;
75430 pPage->hdrOffset = pgno==1 ? 100 : 0;
75449 Pgno pgno, /* Number of the page to fetch */
75458 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
75460 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
75469 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
75472 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
75474 return btreePageFromDbPage(pDbPage, pgno, pBt);
75483 static Pgno btreePagecount(BtShared *pBt){
75486 SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree *p){
75496 Pgno pgno, /* Number of the page to get */
75505 if( pgno>btreePagecount(pBt) ){
75509 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
75516 btreePageFromDbPage(pDbPage, pgno, pBt);
75524 assert( pPage->pgno==pgno || CORRUPT_DB );
75570 Pgno pgno, /* Number of the page to fetch */
75574 int rc = btreeGetPage(pBt, pgno, ppPage, flags);
75787 assert( sizeof(Pgno)==4 );
76270 SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree *p, Pgno mxPage){
76271 Pgno n;
76955 Pgno pgno = pPage->pgno;
76968 Pgno
76969 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
76974 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
76975 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
76995 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
77055 ** the journal needs to be sync()ed before database page pDbPage->pgno
77063 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
77064 Pgno iFreePage, /* The location to move pDbPage to */
77068 Pgno iDbPage = pDbPage->pgno;
77085 pDbPage->pgno = iFreePage;
77101 Pgno nextOvfl = get4byte(pDbPage->aData);
77134 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
77153 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){
77154 Pgno nFreeList; /* Number of pages still on the free-list */
77162 Pgno iPtrPage;
77184 Pgno iFreePg;
77194 Pgno iFreePg; /* Index of free page to move pLastPg to */
77197 Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */
77217 Pgno dbSize = btreePagecount(pBt);
77254 static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){
77256 Pgno nPtrmap; /* Number of PtrMap pages to be freed */
77257 Pgno nFin; /* Return value */
77289 Pgno nOrig = btreePagecount(pBt);
77290 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
77291 Pgno nFin = finalDbSize(pBt, nOrig, nFree);
77333 Pgno nFin; /* Number of pages in database after autovacuuming */
77334 Pgno nFree; /* Number of pages on the freelist initially */
77335 Pgno nVac; /* Number of pages to vacuum */
77336 Pgno iFree; /* The next page to be freed */
77337 Pgno nOrig; /* Database size before freeing */
77806 Pgno iTable, /* Root page of table to open */
77873 Pgno iTable, /* Root page of table to open */
77886 Pgno iTable, /* Root page of table to open */
78064 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
78124 Pgno ovfl, /* Current overflow page number */
78126 Pgno *pPgnoNext /* OUT: Next overflow page number */
78128 Pgno next = 0;
78143 Pgno pgno;
78144 Pgno iGuess = ovfl+1;
78152 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
78153 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
78295 Pgno nextPage;
78309 || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
78311 Pgno *aNew;
78315 aNew = (Pgno*)sqlite3Realloc(pCur->aOverflow, nOvfl*2*sizeof(Pgno));
78323 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
78598 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
78629 pCur->pPage->pgno
78703 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
78728 Pgno subpage;
78729 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
78748 Pgno pgno;
78756 pgno = get4byte(findCell(pPage, pCur->ix));
78757 rc = moveToChild(pCur, pgno);
78773 Pgno pgno;
78780 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
78782 rc = moveToChild(pCur, pgno);
78980 Pgno chldPg;
79223 Pgno chldPg;
79621 Pgno *pPgno, /* Store the page number here */
79622 Pgno nearby, /* Search for a page near this one */
79631 Pgno mxPage; /* Total size of the database file */
79646 Pgno iTrunk;
79698 rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1);
79759 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
79795 Pgno iPage;
79837 *pPgno, closest+1, k, pTrunk->pgno, n-1));
79940 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
79942 Pgno iTrunk = 0; /* Page number of free-list trunk page */
79950 assert( !pMemPage || pMemPage->pgno==iPage );
80043 TRACE(("FREE-PAGE: %u leaf on trunk page %u\n",pPage->pgno,pTrunk->pgno));
80064 TRACE(("FREE-PAGE: %u new trunk page replacing %u\n", pPage->pgno, iTrunk));
80076 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
80089 Pgno ovflPgno;
80111 Pgno iNext = 0;
80192 Pgno pgnoOvfl;
80260 ** pPrior Where to write the pgno of the first overflow page
80307 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
80441 Pgno iChild /* If non-zero, replace first 4 bytes with this value */
81115 Pgno pgnoNew; /* Page number of pNew */
81166 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
81194 0, pPage->pgno);
81217 Pgno n;
81230 Pgno ovfl = get4byte(&z[info.nSize-4]);
81232 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
81235 Pgno child = get4byte(z);
81237 assert( n==pPage->pgno && e==PTRMAP_BTREE );
81241 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
81243 assert( n==pPage->pgno && e==PTRMAP_BTREE );
81273 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
81378 Pgno pgno; /* Temp var to store a page number in */
81380 Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */
81435 pgno = get4byte(pRight);
81438 rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
81456 pgno = get4byte(apDiv[i]);
81461 pgno = get4byte(apDiv[i]);
81759 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
81761 apOld[0]->pgno, apOld[0]->nCell,
81762 nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0,
81763 nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0
81785 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
81794 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
81815 aPgno[i] = apNew[i]->pgno;
81822 if( apNew[j]->pgno < apNew[iB]->pgno ) iB = j;
81831 Pgno pgnoA = apNew[i]->pgno;
81832 Pgno pgnoB = apNew[iB]->pgno;
81833 Pgno pgnoTemp = (PENDING_BYTE/pBt->pageSize)+1;
81839 apNew[i]->pgno = pgnoB;
81840 apNew[iB]->pgno = pgnoA;
81846 apNew[0]->pgno, szNew[0], cntNew[0],
81847 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
81849 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
81851 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
81853 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
81860 put4byte(pRight, apNew[nNew-1]->pgno);
81919 || pNew->pgno!=aPgno[iOld]
81923 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
81989 rc = insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno);
82093 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
82156 Pgno pgnoChild = 0; /* Page number of the new child page */
82168 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
82171 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
82183 TRACE(("BALANCE: copy root %u into %u\n", pRoot->pgno, pChild->pgno));
82292 && pParent->pgno!=1
82421 Pgno ovflPgno; /* Next overflow page to write */
82682 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
82699 Pgno ovfl = get4byte(&newCell[szNew-4]);
82700 ptrmapPut(p->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);
82859 Pgno ovflIn = 0;
82904 Pgno pgnoNew = 0; /* Prevent harmless static-analyzer warning */
82909 ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);
83063 Pgno n;
83071 n = pCur->apPage[iCellDepth+1]->pgno;
83073 n = pCur->pPage->pgno;
83158 static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){
83161 Pgno pgnoRoot;
83176 Pgno pgnoMove; /* Move a page here to make room for the root-page */
83222 Pgno iPtrPage = 0;
83303 SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, Pgno *piTable, int flags){
83317 Pgno pgno, /* Page number to clear */
83329 if( pgno>btreePagecount(pBt) ){
83330 return SQLITE_CORRUPT_PGNO(pgno);
83332 rc = getAndInitPage(pBt, pgno, &pPage, 0);
83335 && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
83388 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
83395 invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1);
83397 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
83432 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
83446 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
83459 Pgno maxRootPgno;
83752 static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){
83761 static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){
83776 static int checkRef(IntegrityCk *pCheck, Pgno iPage){
83797 Pgno iChild, /* Child page number */
83799 Pgno iParent /* Expected pointer map parent page number */
83803 Pgno iPtrmapParent;
83827 Pgno iPage, /* Page number for first page in the list */
83838 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
83856 Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
83961 Pgno iPage, /* Page number of the page to check */
83969 int pgno; /* Page number */
84047 pgno = get4byte(&data[hdr+8]);
84051 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
84054 depth = checkTreePage(pCheck, pgno, &maxKey, maxKey);
84099 Pgno pgnoOvfl; /* First page of the overflow chain */
84113 pgno = get4byte(pCell);
84116 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
84119 d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey);
84248 Pgno *aRoot, /* An array of root pages numbers for individual trees */
84255 Pgno i;
84318 Pgno mx = 0;
84319 Pgno mxInHdr;
84717 Pgno iNext; /* Page number of the next source page to copy */
84726 Pgno nRemaining; /* Number of pages left to copy */
84727 Pgno nPagecount; /* Total number of pages to copy */
84918 Pgno iSrcPg, /* Source database page to backup */
84943 Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
85080 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
85081 const Pgno iSrcPg = p->iNext; /* Source page number */
85095 if( p->iNext>(Pgno)nSrcPage ){
85162 Pgno iPg;
85181 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
85203 const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
85353 Pgno iPage,
85376 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
103479 Pgno pgno;
103484 pgno = 0;
103491 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
103493 pOut->u.i = pgno;
103711 Pgno *aRoot; /* Array of rootpage numbers for tables to be checked */
103722 assert( aRoot[0]==(Pgno)nRoot );
109381 Pgno iRoot = (Pgno)pOp->p2;
126346 Pgno iTab; /* The root page of the table to be locked */
126364 Pgno iTab, /* Root page number of the table to be locked */
126401 Pgno iTab, /* Root page number of the table to be locked */
129567 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){
129644 Pgno iTab = pTab->tnum;
129645 Pgno iDestroyed = 0;
129649 Pgno iLargest = 0;
129655 Pgno iIdx = pIdx->tnum;
130091 Pgno tnum; /* Root page of index */
130112 tnum = (Pgno)memRootPage;
130751 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
138905 Pgno tnum = pOp->p2;
157538 Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */
191077 SQLITE_PRIVATE int sqlite3CorruptPgnoError(int lineno, Pgno pgno){
191079 sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno);
232295 ** SELECT data FROM sqlite_dbpage('aux1') WHERE pgno=123;
232322 Pgno pgno; /* Current page number */
232323 Pgno mxPgno; /* Last page to visit on this scan */
232334 Pgno pgnoTrunc; /* Size to truncate to */
232363 "CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
232391 ** 1 schema=main, pgno=?1
232393 ** 3 schema=?1, pgno=?2
232424 /* Check for constraints against pgno */
232460 pCsr->pgno = 0;
232483 pCsr->pgno++;
232489 return pCsr->pgno > pCsr->mxPgno;
232496 ** 1 schema=main, pgno=?1
232498 ** 3 schema=?1, pgno=?2
232517 pCsr->pgno = 1;
232536 pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
232537 if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
232538 pCsr->pgno = 1;
232541 pCsr->mxPgno = pCsr->pgno;
232544 assert( pCsr->pgno==1 );
232559 case 0: { /* pgno */
232560 sqlite3_result_int64(ctx, (sqlite3_int64)pCsr->pgno);
232565 if( pCsr->pgno==(Pgno)((PENDING_BYTE/pCsr->szPage)+1) ){
232570 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
232590 *pRowid = pCsr->pgno;
232619 Pgno pgno;
232639 pgno = (Pgno)sqlite3_value_int64(argv[2]);
232642 pgno = (Pgno)sqlite3_value_int64(argv[0]);
232643 if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){
232660 if( pgno<1 || NEVER(pBt==0) ){
232668 if( sqlite3_value_type(argv[3])==SQLITE_NULL && isInsert && pgno>1 ){
232669 /* "INSERT INTO dbpage($PGNO,NULL)" causes page number $PGNO and
232672 pTab->pgnoTrunc = pgno-1;
232673 pgno = 1;
232686 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);
250368 #define fts5_dri(segid, dlidx, height, pgno) ( \
250372 ((i64)(pgno)) \
250375 #define FTS5_SEGMENT_ROWID(segid, pgno) fts5_dri(segid, 0, 0, pgno)
250376 #define FTS5_DLIDX_ROWID(segid, height, pgno) fts5_dri(segid, 1, height, pgno)
250514 int pgno; /* Page number for this page */
250521 int pgno; /* Page number for this page */
252526 int pgno;
252531 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
252532 pgno);
252540 pgnoLast = pgno;
252753 "SELECT pgno FROM '%q'.'%q_idx' WHERE "
252854 "SELECT pgno FROM '%q'.'%q_idx' WHERE "
253668 int pgno = pSeg->iLeafPgno;
253675 pgnoSave = pgno+1;
253688 pgno++;
253689 pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
253693 if( pgno==pgnoSave ){
254288 assert( pDlidx->pgno!=0 );
254290 FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
254390 pWriter->iBtPage = pWriter->writer.pgno;
254448 FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
254457 pDlidx[1].pgno = pDlidx->pgno;
254459 sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx[1].buf, pDlidx->pgno);
254467 pDlidx->pgno++;
254475 i64 iPgno = (i==0 ? pWriter->writer.pgno : pDlidx[-1].pgno);
254509 iRowid = FTS5_SEGMENT_ROWID(pWriter->iSegid, pPage->pgno);
254517 pPage->pgno++;
254569 if( pPage->pgno!=1 ){
254609 pWriter->aDlidx[0].pgno = pPage->pgno;
254692 assert( pLeaf->pgno>=1 );
254696 *pnLeaf = pLeaf->pgno-1;
254697 if( pLeaf->pgno>1 ){
254723 pWriter->writer.pgno = 1;
254737 "INSERT INTO '%q'.'%q_idx'(segid,term,pgno) VALUES(?,?,?)",
254869 writer.writer.pgno = pSeg->pgnoLast+1;
255175 ** DELETE FROM %_idx WHERE (segid, (pgno/2)) = ($iSegid, $iPgno);
255192 "DELETE FROM '%q'.'%q_idx' WHERE (segid, (pgno/2)) = (?1, ?2)",
255222 int pgno;
255227 for(pgno=iPgno; p->rc==SQLITE_OK && pgno<=pSeg->pgnoLast; pgno++){
255228 i64 iRowid = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno);
255413 int pgno = pSeg->iLeafPgno+1;
255414 fts5SecureDeleteOverflow(p, pSeg->pSeg, pgno, &bLastInDoclist);
256952 "segid, term, pgno, PRIMARY KEY(segid, term)",
258261 ** Instead, it tests that the same set of pgno/rowid combinations are
258279 int pgno = fts5DlidxIterPgno(pDlidx);
258280 assert( pgno>iLeaf );
258281 cksum1 += iRowid + ((i64)pgno<<32);
258291 int pgno = fts5DlidxIterPgno(pDlidx);
258293 cksum2 += iRowid + ((i64)pgno<<32);
258555 "SELECT segid, term, (pgno>>1), (pgno&1) FROM %Q.'%q_idx' WHERE segid=%d "
258847 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{%s%ssegid=%d h=%d pgno=%d}",
259304 int segid, pgno;
259307 "should be: fts5_rowid('segment', segid, pgno))", -1
259311 pgno = sqlite3_value_int(apVal[2]);
259312 iRowid = FTS5_SEGMENT_ROWID(segid, pgno);
Indexes created Tue May 26 00:24:38 UTC 2026