Lines Matching refs:pgno
7522 typedef u32 Pgno;
7542 #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
7600 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
7602 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
7609 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
7637 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
7641 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
7688 Pgno pgno; /* Page number for this page */
7747 SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
7756 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
7758 /* Remove all pages with pgno>x. Reset the cache if x==0 */
7759 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
10441 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
29784 if( p->pgno==1 ){
29855 Pgno pgno, /* Page number to obtain */
29864 assert( pgno>0 );
29883 pPage = sqlite3GlobalConfig.pcache.xFetch(pCache->pCache, pgno, eCreate);
29911 pPage = sqlite3GlobalConfig.pcache.xFetch(pCache->pCache, pgno, 2);
29920 pPage->pgno = pgno;
29923 assert( pPage->pgno==pgno );
29930 if( pgno==1 ){
29979 if( p->pgno==1 ){
30036 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
30040 sqlite3GlobalConfig.pcache.xRekey(pCache->pCache, p, p->pgno, newPgno);
30041 p->pgno = newPgno;
30049 ** Drop every cache entry whose page number is greater than "pgno". The
30051 ** other than page 1 with a page number greater than pgno.
30053 ** If there is a reference to page 1 and the pgno parameter passed to this
30057 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
30063 if( p->pgno>pgno ){
30068 if( pgno==0 && pCache->pPage1 ){
30070 pgno = 1;
30072 sqlite3GlobalConfig.pcache.xTruncate(pCache->pCache, pgno+1);
30093 ** Merge two lists of pages connected by pDirty and in pgno order.
30100 if( pA->pgno<pB->pgno ){
30121 ** Sort the list of pages in accending order by pgno. Pages are
31576 Pgno nOrig; /* Original number of pages in file */
31577 Pgno iSubRec; /* Index of first record in sub-journal */
31709 Pgno dbSize; /* Number of pages in the database */
31710 Pgno dbOrigSize; /* dbSize before the current transaction */
31711 Pgno dbFileSize; /* Number of pages in the database file */
31731 Pgno mxPgno; /* Maximum allowed size of the database */
31742 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
31853 Pgno pgno = pPg->pgno;
31858 if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
31869 return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
32474 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
32480 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
32518 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
32522 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
32528 if( pgno<=p->nOrig ){
32529 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
32859 Pgno pgno; /* The page number of a page in journal */
32876 rc = read32bits(jfd, *pOffset, &pgno);
32887 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
32891 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
32902 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
32940 pPg = pager_lookup(pPager, pgno);
32943 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
32951 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
32953 if( pgno>pPager->dbFileSize ){
32954 pPager->dbFileSize = pgno;
32957 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
32958 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
32959 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
32979 if( (rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1))!=SQLITE_OK ){
33022 if( pgno==1 ){
33027 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
33188 static int pager_truncate(Pager *pPager, Pgno nPage){
33304 Pgno mxPg = 0; /* Size of the original file in pages */
33897 Pgno nPage; /* Value to return via *pnPage */
33919 nPage = (Pgno)(n / pPager->pageSize);
33933 pPager->mxPgno = (Pgno)nPage;
34021 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
34036 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
34099 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
34100 return pPg->pgno;
34309 Pgno pgno = pList->pgno;
34321 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
34322 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
34326 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
34335 if( pgno==1 ){
34338 if( pgno>pPager->dbFileSize ){
34339 pPager->dbFileSize = pgno;
34343 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
34346 PAGERID(pPager), pgno, pager_pagehash(pList)));
34347 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
34351 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
34367 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
34383 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
34384 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
34386 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
34387 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
34395 rc = addToSavepointBitvecs(pPager, pPg->pgno);
34486 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
34499 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
34914 Pgno pgno = pPg->pgno; /* Page number to read */
34926 iOffset = (pgno-1)*(i64)pPager->pageSize;
34931 if( pgno==1 ){
34935 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
34939 IOTRACE(("PGIN %p %d\n", pPager, pgno));
34941 PAGERID(pPager), pgno, pager_pagehash(pPg)));
35173 ** Acquire a reference to page number pgno in pager pPager (a page
35205 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
35224 Pgno pgno, /* Page number to fetch */
35234 if( pgno==0 ){
35243 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
35253 assert( (*ppPage)->pgno==pgno );
35259 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
35274 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
35284 if( MEMDB || nMax<(int)pgno || noContent || !isOpen(pPager->fd) ){
35285 if( pgno>pPager->mxPgno ){
35297 if( pgno<=pPager->dbOrigSize ){
35298 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
35301 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
35306 IOTRACE(("ZERO %p %d\n", pPager, pgno));
35345 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
35348 assert( pgno!=0 );
35351 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
35628 if( pPg->pgno<=pPager->dbOrigSize ){
35635 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
35636 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
35638 rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno);
35648 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
35652 PAGERID(pPager), pPg->pgno,
35676 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
35679 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
35690 PAGERID(pPager), pPg->pgno,
35708 if( pPager->dbSize<pPg->pgno ){
35709 pPager->dbSize = pPg->pgno;
35733 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
35736 Pgno nPageCount; /* Total number of pages in database file */
35737 Pgno pg1; /* First page of the sector pPg is located on. */
35753 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
35756 if( pPg->pgno>nPageCount ){
35757 nPage = (pPg->pgno - pg1)+1;
35764 assert(pg1<=pPg->pgno);
35765 assert((pg1+nPage)>pPg->pgno);
35768 Pgno pg = pg1+ii;
35770 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
35845 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
35846 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
36073 Pgno i; /* Iterator variable */
36074 const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
36075 const Pgno dbSize = pPager->dbSize; /* Database image size */
36117 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
36499 void *(*xCodec)(void*,void*,Pgno,int),
36518 ** Move the page pPg to location pgno in the file.
36521 ** pgno (which we call pPgOld) though that page is allowed to be
36522 ** in cache. If the page previously located at pgno is not already
36542 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
36544 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
36546 Pgno origPgno; /* The original page number */
36572 ** subjournalPage() may need to allocate space to store pPg->pgno into
36584 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
36585 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
36587 /* If the journal needs to be sync()ed before page pPg->pgno can
36588 ** be written to, store pPg->pgno in local variable needSyncPgno.
36591 ** the journal needs to be sync()ed before database page pPg->pgno
36595 needSyncPgno = pPg->pgno;
36596 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
36601 /* If the cache contains a page with page-number pgno, remove it
36603 ** page pgno before the 'move' operation, it needs to be retained
36607 pPgOld = pager_lookup(pPager, pgno);
36621 origPgno = pPg->pgno;
36622 sqlite3PcacheMove(pPg, pgno);
37093 Pgno pgno; /* Page number for this page */
37112 Pgno iTable; /* Root page of table */
37284 Pgno pgnoRoot; /* The root page of this tree */
37296 Pgno *aOverflow; /* Cache of overflow page locations */
37348 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
37349 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
37350 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
37353 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
37354 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
37355 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
37424 Pgno nPage; /* Number of pages in the database */
37897 Pgno iRoot, /* Root page of b-tree */
37902 Pgno iTab = 0;
37976 static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
37996 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
38068 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
38265 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
38299 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
38311 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
38312 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
38324 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
38326 return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
38395 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
38511 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
38513 Pgno iPtrMap, ret;
38516 iPtrMap = (pgno-2)/nPagesPerMapPage;
38528 ** so that it maps to type 'eType' and parent page number 'pgno'.
38534 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
38537 Pgno iPtrmap; /* The pointer map page number */
38585 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
38819 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
38820 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
39117 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
39152 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
39264 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
39293 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
39298 pPage->pgno = pgno;
39299 pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
39316 Pgno pgno, /* Number of the page to fetch */
39324 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
39326 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
39335 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
39338 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
39340 return btreePageFromDbPage(pDbPage, pgno, pBt);
39349 static Pgno pagerPagecount(BtShared *pBt){
39355 return (Pgno)nPage;
39368 Pgno pgno, /* Number of the page to get */
39372 TESTONLY( Pgno iLastPg = pagerPagecount(pBt); )
39375 rc = btreeGetPage(pBt, pgno, ppPage, 0);
39387 assert( (pgno>0 && pgno<=iLastPg) || rc!=SQLITE_OK );
39388 testcase( pgno==0 );
39389 testcase( pgno==iLastPg );
39569 assert( sizeof(Pgno)==4 );
40342 Pgno pgno = pPage->pgno;
40357 Pgno childPgno = get4byte(pCell);
40358 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
40363 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
40364 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
40386 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
40441 ** the journal needs to be sync()ed before database page pDbPage->pgno
40449 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
40450 Pgno iFreePage, /* The location to move pDbPage to */
40454 Pgno iDbPage = pDbPage->pgno;
40470 pDbPage->pgno = iFreePage;
40486 Pgno
40519 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
40539 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
40540 Pgno nFreeList; /* Number of pages still on the free-list */
40548 Pgno iPtrPage;
40570 Pgno iFreePg;
40580 Pgno iFreePg; /* Index of free page to move pLastPg to */
40681 Pgno nFin; /* Number of pages in database after autovacuuming */
40682 Pgno nFree; /* Number of pages on the freelist initially */
40683 Pgno nPtrmap; /* Number of PtrMap pages to be freed */
40684 Pgno iFree; /* The next page to be freed */
40686 Pgno nOrig; /* Database size before freeing */
41112 pCur->pgnoRoot = (Pgno)iTable;
41350 Pgno ovfl, /* Current overflow page number */
41352 Pgno *pPgnoNext /* OUT: Next overflow page number */
41354 Pgno next = 0;
41369 Pgno pgno;
41370 Pgno iGuess = ovfl+1;
41378 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
41379 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
41511 Pgno nextPage;
41525 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
41780 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
41808 pCur->apPage[pCur->iPage]->pgno
41886 assert( pRoot->pgno==pCur->pgnoRoot );
41895 Pgno subpage;
41896 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
41914 Pgno pgno;
41922 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
41923 rc = moveToChild(pCur, pgno);
41939 Pgno pgno;
41946 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
41948 rc = moveToChild(pCur, pgno);
42094 Pgno chldPg;
42395 Pgno *pPgno,
42396 Pgno nearby,
42405 Pgno mxPage; /* Total size of the database file */
42417 Pgno iTrunk;
42510 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
42546 Pgno iPage;
42582 *pPgno, closest+1, k, pTrunk->pgno, n-1));
42671 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
42673 Pgno iTrunk = 0; /* Page number of free-list trunk page */
42681 assert( !pMemPage || pMemPage->pgno==iPage );
42764 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
42785 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
42797 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
42807 Pgno ovflPgno;
42823 Pgno iNext = 0;
42874 Pgno pgnoOvfl = 0;
42923 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
43076 Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
43237 Pgno pgnoNew; /* Page number of pNew */
43273 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
43300 0, pPage->pgno, &rc);
43322 Pgno n;
43335 Pgno ovfl = get4byte(&z[info.iOverflow]);
43337 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
43340 Pgno child = get4byte(z);
43342 assert( n==pPage->pgno && e==PTRMAP_BTREE );
43346 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
43348 assert( n==pPage->pgno && e==PTRMAP_BTREE );
43378 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
43485 Pgno pgno; /* Temp var to store a page number in */
43492 TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
43538 pgno = get4byte(pRight);
43540 rc = getAndInitPage(pBt, pgno, &apOld[i]);
43550 pgno = get4byte(apDiv[i]);
43555 pgno = get4byte(apDiv[i]);
43735 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
43738 apOld[0]->pgno,
43739 nOld>=2 ? apOld[1]->pgno : 0,
43740 nOld>=3 ? apOld[2]->pgno : 0
43746 if( apOld[0]->pgno<=1 ){
43761 rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
43768 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
43801 int minV = apNew[i]->pgno;
43804 if( apNew[j]->pgno<(unsigned)minV ){
43806 minV = apNew[j]->pgno;
43812 t = apNew[i]->pgno;
43819 apNew[0]->pgno, szNew[0],
43820 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
43821 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
43822 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
43823 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
43826 put4byte(pRight, apNew[nNew-1]->pgno);
43892 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
44007 if( isDivider || pOld->pgno!=pNew->pgno ){
44009 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
44020 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
44076 Pgno pgnoChild = 0; /* Page number of the new child page */
44088 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
44091 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
44103 TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
44170 && pParent->pgno!=1
44327 pCur->pgnoRoot, nKey, nData, pPage->pgno,
44471 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
44530 Pgno pgnoRoot;
44544 Pgno pgnoMove; /* Move a page here to make room for the root-page */
44587 Pgno iPtrPage = 0;
44663 Pgno pgno, /* Page number to clear */
44673 if( pgno>pagerPagecount(pBt) ){
44677 rc = getAndInitPage(pBt, pgno, &pPage);
44730 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
44732 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
44758 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
44779 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
44795 Pgno maxRootPgno;
45047 static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
45068 Pgno iChild, /* Child page number */
45070 Pgno iParent, /* Expected pointer map parent page number */
45075 Pgno iPtrmapParent;
45116 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
45134 Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
45190 int i, rc, depth, d2, pgno, cnt;
45209 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
45257 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
45269 pgno = get4byte(pCell);
45272 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
45275 d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
45284 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
45289 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
45292 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
45413 Pgno i;
45725 Pgno iNext; /* Page number of the next source page to copy */
45734 Pgno nRemaining; /* Number of pages left to copy */
45735 Pgno nPagecount; /* Total number of pages to copy */
45894 static int backupOnePage(sqlite3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
45922 Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
46029 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
46030 const Pgno iSrcPg = p->iNext; /* Source page number */
46044 if( p->iNext>(Pgno)nSrcPage ){
46120 const Pgno iSrcPg = (Pgno)((iOff/nSrcPagesize)+1);
46239 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
52871 int pgno;
55550 int pgno;
55552 rc = sqlite3BtreeCreateTable(u.ax.pCx->pBt, &pgno, BTREE_ZERODATA);
55554 assert( pgno==MASTER_ROOT+1 );
55555 rc = sqlite3BtreeCursor(u.ax.pCx->pBt, pgno, 1,
57014 int pgno;
57019 u.bt.pgno = 0;
57030 rc = sqlite3BtreeCreateTable(u.bt.pDb->pBt, &u.bt.pgno, u.bt.flags);
57031 pOut->u.i = u.bt.pgno;
