Lines Matching defs:pgno
9612 typedef u32 Pgno;
9632 #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
9713 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
9715 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
9723 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
9768 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
9776 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
9825 Pgno pgno; /* Page number for this page */
9885 SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
9894 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
9896 /* Remove all pages with pgno>x. Reset the cache if x==0 */
9897 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
12924 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
13940 Pgno pgnoRoot; /* Root page of the open btree cursor */
38063 if( p->pgno==1 ){
38150 Pgno pgno, /* Page number to obtain */
38160 assert( pgno>0 );
38190 pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
38213 pPg->pgno, pgno,
38223 pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
38236 pPgHdr->pgno = pgno;
38239 assert( pPgHdr->pgno==pgno );
38247 if( pgno==1 ){
38296 if( p->pgno==1 ){
38353 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
38357 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
38358 p->pgno = newPgno;
38366 ** Drop every cache entry whose page number is greater than "pgno". The
38368 ** other than page 1 with a page number greater than pgno.
38370 ** If there is a reference to page 1 and the pgno parameter passed to this
38374 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
38380 /* This routine never gets call with a positive pgno except right
38382 ** it must be that pgno==0.
38384 assert( p->pgno>0 );
38385 if( ALWAYS(p->pgno>pgno) ){
38390 if( pgno==0 && pCache->pPage1 ){
38392 pgno = 1;
38394 sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
38415 ** Merge two lists of pages connected by pDirty and in pgno order.
38422 if( pA->pgno<pB->pgno ){
38443 ** Sort the list of pages in accending order by pgno. Pages are
39064 unsigned int iLimit /* Drop pages with this pgno or larger */
40203 SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
40207 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
40214 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
40225 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
40695 Pgno nOrig; /* Original number of pages in file */
40696 Pgno iSubRec; /* Index of first record in sub-journal */
40895 Pgno dbSize; /* Number of pages in the database */
40896 Pgno dbOrigSize; /* dbSize before the current transaction */
40897 Pgno dbFileSize; /* Number of pages in the database file */
40898 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
40927 Pgno mxPgno; /* Maximum allowed size of the database */
40939 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
41274 Pgno pgno = pPg->pgno;
41278 if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
41289 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
41931 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
41937 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
41969 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
41973 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
41979 if( pgno<=p->nOrig ){
41980 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
42113 static int pager_truncate(Pager *pPager, Pgno nPage);
42404 Pgno pgno; /* The page number of a page in journal */
42434 rc = read32bits(jfd, *pOffset, &pgno);
42445 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
42449 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
42463 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
42469 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
42512 pPg = pager_lookup(pPager, pgno);
42517 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
42529 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
42533 if( pgno>pPager->dbFileSize ){
42534 pPager->dbFileSize = pgno;
42537 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
42538 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
42539 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
42561 rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
42606 if( pgno==1 ){
42611 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
42770 static int pager_truncate(Pager *pPager, Pgno nPage){
42918 Pgno mxPg = 0; /* Size of the original file in pages */
43123 Pgno pgno = pPg->pgno; /* Page number to read */
43137 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
43144 if( pgno==1 ){
43164 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
43168 IOTRACE(("PGIN %p %d\n", pPager, pgno));
43170 PAGERID(pPager), pgno, pager_pagehash(pPg)));
43210 static int pagerUndoCallback(void *pCtx, Pgno iPg){
43222 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
43265 rc = pagerUndoCallback((void *)pPager, pList->pgno);
43284 Pgno nTruncate, /* Database size after this commit */
43298 assert( p->pgno < p->pDirty->pgno );
43312 if( p->pgno<=nTruncate ){
43323 if( pList->pgno==1 ) pager_write_changecounter(pList);
43330 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
43385 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
43386 Pgno nPage; /* Value to return via *pnPage */
43413 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
43421 pPager->mxPgno = (Pgno)nPage;
43454 Pgno nPage; /* Size of the database file */
43882 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
44060 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
44080 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
44123 ** Obtain a reference to a memory mapped page object for page number pgno.
44134 Pgno pgno, /* Page number */
44148 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
44163 p->pgno = pgno;
44181 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
44268 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
44269 return pPg->pgno;
44481 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
44489 Pgno pgno = pList->pgno;
44499 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
44500 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
44504 if( pList->pgno==1 ) pager_write_changecounter(pList);
44507 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
44516 if( pgno==1 ){
44519 if( pgno>pPager->dbFileSize ){
44520 pPager->dbFileSize = pgno;
44525 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
44528 PAGERID(pPager), pgno, pager_pagehash(pList)));
44529 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
44532 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
44566 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
44585 || pPg->pgno>pPager->dbOrigSize
44596 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
44597 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
44598 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
44607 rc = addToSavepointBitvecs(pPager, pPg->pgno);
44711 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
44725 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
45145 Pgno nPage; /* Number of pages in database file */
45390 Pgno nPage = 0;
45465 ** Acquire a reference to page number pgno in pager pPager (a page
45497 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
45516 Pgno pgno, /* Page number to fetch */
45529 const int bMmapOk = (pgno!=1 && USEFETCH(pPager)
45540 if( pgno==0 ){
45551 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
45559 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
45564 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
45567 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
45569 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
45582 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
45592 assert( (*ppPage)->pgno==pgno );
45598 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
45611 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
45616 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
45617 if( pgno>pPager->mxPgno ){
45629 if( pgno<=pPager->dbOrigSize ){
45630 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
45633 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
45638 IOTRACE(("ZERO %p %d\n", pPager, pgno));
45641 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
45678 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
45681 assert( pgno!=0 );
45684 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
45945 if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
45953 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
45956 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
45968 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
45975 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
45979 PAGERID(pPager), pPg->pgno,
45985 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
45988 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
45998 PAGERID(pPager), pPg->pgno,
46015 if( pPager->dbSize<pPg->pgno ){
46016 pPager->dbSize = pPg->pgno;
46047 Pgno nPageCount; /* Total number of pages in database file */
46048 Pgno pg1; /* First page of the sector pPg is located on. */
46052 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
46066 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
46069 if( pPg->pgno>nPageCount ){
46070 nPage = (pPg->pgno - pg1)+1;
46077 assert(pg1<=pPg->pgno);
46078 assert((pg1+nPage)>pPg->pgno);
46081 Pgno pg = pg1+ii;
46083 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
46155 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
46156 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
46468 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
46888 void *(*xCodec)(void*,void*,Pgno,int),
46913 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
46927 ** Move the page pPg to location pgno in the file.
46930 ** pgno (which we call pPgOld) though that page is allowed to be
46931 ** in cache. If the page previously located at pgno is not already
46951 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
46953 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
46955 Pgno origPgno; /* The original page number */
46985 ** subjournalPage() may need to allocate space to store pPg->pgno into
46997 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
46998 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
47000 /* If the journal needs to be sync()ed before page pPg->pgno can
47001 ** be written to, store pPg->pgno in local variable needSyncPgno.
47004 ** the journal needs to be sync()ed before database page pPg->pgno
47008 needSyncPgno = pPg->pgno;
47010 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
47014 /* If the cache contains a page with page-number pgno, remove it
47016 ** page pgno before the 'move' operation, it needs to be retained
47020 pPgOld = pager_lookup(pPager, pgno);
47033 origPgno = pPg->pgno;
47034 sqlite3PcacheMove(pPg, pgno);
48185 u32 pgno; /* Page number of the frame */
48197 pgno = sqlite3Get4byte(&aFrame[0]);
48198 if( pgno==0 ){
48220 *piPage = pgno;
48639 u32 pgno; /* Database page number for frame */
48646 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
48648 rc = walIndexAppend(pWal, iFrame, pgno);
48822 u32 iMin; /* Result pgno must be greater than iMin */
48887 Pgno dbpage;
49772 ** Search the wal file for page pgno. If found, set *piRead to the frame that
49773 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
49781 Pgno pgno, /* Database page number to read data for */
49803 ** pgno. Each iteration of the following for() loop searches one
49820 ** (aPgno[iFrame]==pgno):
49840 for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
49842 if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
49860 if( walFramePgno(pWal, iTest)==pgno ){
49898 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
49977 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
49980 Pgno iMax = pWal->hdr.mxFrame;
49981 Pgno iFrame;
50184 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
50200 Pgno nTruncate, /* Database size after this commit */
50350 rc = walIndexAppend(pWal, iFrame, p->pgno);
50355 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
50891 Pgno pgno; /* Page number for this page */
50910 Pgno iTable; /* Root page of table */
51094 Pgno *aOverflow; /* Cache of overflow page locations */
51098 Pgno pgnoRoot; /* The root page of this tree */
51169 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
51170 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
51171 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
51174 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
51175 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
51176 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
51252 Pgno nPage; /* Number of pages in the database */
51681 Pgno iRoot, /* Root page of b-tree */
51686 Pgno iTab = 0;
51760 static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
51780 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
51852 static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
52041 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
52075 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
52078 assert( pgno<=pBt->nPage );
52084 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
52085 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
52097 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
52099 return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
52176 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
52318 ** Return 0 (not a valid page) for pgno==1 since there is
52322 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
52324 Pgno iPtrMap, ret;
52326 if( pgno<2 ) return 0;
52328 iPtrMap = (pgno-2)/nPagesPerMapPage;
52340 ** so that it maps to type 'eType' and parent page number 'pgno'.
52346 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
52349 Pgno iPtrmap; /* The pointer map page number */
52398 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
52633 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
52634 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
52931 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
52967 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
53081 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
53111 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
53116 pPage->pgno = pgno;
53117 pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
53134 Pgno pgno, /* Number of the page to fetch */
53143 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
53145 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
53154 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
53157 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
53159 return btreePageFromDbPage(pDbPage, pgno, pBt);
53168 static Pgno btreePagecount(BtShared *pBt){
53187 Pgno pgno, /* Number of the page to get */
53195 if( pgno>btreePagecount(pBt) ){
53198 rc = btreeGetPage(pBt, pgno, ppPage, bReadonly);
53207 testcase( pgno==0 );
53208 assert( pgno!=0 || rc==SQLITE_CORRUPT );
53420 assert( sizeof(Pgno)==4 );
54370 Pgno pgno = pPage->pgno;
54385 Pgno childPgno = get4byte(pCell);
54386 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
54391 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
54392 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
54414 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
54470 ** the journal needs to be sync()ed before database page pDbPage->pgno
54478 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
54479 Pgno iFreePage, /* The location to move pDbPage to */
54483 Pgno iDbPage = pDbPage->pgno;
54499 pDbPage->pgno = iFreePage;
54515 Pgno nextOvfl = get4byte(pDbPage->aData);
54548 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
54567 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){
54568 Pgno nFreeList; /* Number of pages still on the free-list */
54576 Pgno iPtrPage;
54598 Pgno iFreePg;
54608 Pgno iFreePg; /* Index of free page to move pLastPg to */
54611 Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */
54663 static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){
54665 Pgno nPtrmap; /* Number of PtrMap pages to be freed */
54666 Pgno nFin; /* Return value */
54698 Pgno nOrig = btreePagecount(pBt);
54699 Pgno nFree = get4byte(&pBt->pPage1->aData[36]);
54700 Pgno nFin = finalDbSize(pBt, nOrig, nFree);
54740 Pgno nFin; /* Number of pages in database after autovacuuming */
54741 Pgno nFree; /* Number of pages on the freelist initially */
54742 Pgno iFree; /* The next page to be freed */
54743 Pgno nOrig; /* Database size before freeing */
55170 pCur->pgnoRoot = (Pgno)iTable;
55378 Pgno ovfl, /* Current overflow page number */
55380 Pgno *pPgnoNext /* OUT: Next overflow page number */
55382 Pgno next = 0;
55397 Pgno pgno;
55398 Pgno iGuess = ovfl+1;
55406 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
55407 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
55548 Pgno nextPage;
55563 Pgno *aNew = (Pgno*)sqlite3DbRealloc(
55564 pCur->pBtree->db, pCur->aOverflow, nOvfl*2*sizeof(Pgno)
55574 memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno));
55832 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
55867 pCur->apPage[pCur->iPage]->pgno
55930 assert( pRoot->pgno==pCur->pgnoRoot );
55954 Pgno subpage;
55955 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
55973 Pgno pgno;
55981 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
55982 rc = moveToChild(pCur, pgno);
55998 Pgno pgno;
56005 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
56007 rc = moveToChild(pCur, pgno);
56169 Pgno chldPg;
56533 Pgno *pPgno, /* Store the page number here */
56534 Pgno nearby, /* Search for a page near this one */
56543 Pgno mxPage; /* Total size of the database file */
56556 Pgno iTrunk;
56661 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
56697 Pgno iPage;
56739 *pPgno, closest+1, k, pTrunk->pgno, n-1));
56849 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
56851 Pgno iTrunk = 0; /* Page number of free-list trunk page */
56859 assert( !pMemPage || pMemPage->pgno==iPage );
56940 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
56961 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
56973 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
56983 Pgno ovflPgno;
57002 Pgno iNext = 0;
57071 Pgno pgnoOvfl = 0;
57120 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
57269 Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
57429 Pgno pgnoNew; /* Page number of pNew */
57466 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
57493 0, pPage->pgno, &rc);
57515 Pgno n;
57528 Pgno ovfl = get4byte(&z[info.iOverflow]);
57530 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
57533 Pgno child = get4byte(z);
57535 pgno && e==PTRMAP_BTREE );
57539 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
57541 assert( n==pPage->pgno && e==PTRMAP_BTREE );
57571 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
57682 Pgno pgno; /* Temp var to store a page number in */
57689 TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
57736 pgno = get4byte(pRight);
57738 rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
57748 pgno = get4byte(apDiv[i]);
57753 pgno = get4byte(apDiv[i]);
57961 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
57965 apOld[0]->pgno,
57966 nOld>=2 ? apOld[1]->pgno : 0,
57967 nOld>=3 ? apOld[2]->pgno : 0
57973 if( apOld[0]->pgno<=1 ){
57988 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
57995 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
58028 int minV = apNew[i]->pgno;
58031 if( apNew[j]->pgno<(unsigned)minV ){
58033 minV = apNew[j]->pgno;
58044 apNew[0]->pgno, szNew[0],
58045 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
58046 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
58047 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
58048 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
58051 put4byte(pRight, apNew[nNew-1]->pgno);
58117 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
58234 if( isDivider || pOld->pgno!=pNew->pgno ){
58236 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
58247 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
58306 Pgno pgnoChild = 0; /* Page number of the new child page */
58318 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
58321 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
58333 TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
58403 && pParent->pgno!=1
58568 pCur->pgnoRoot, nKey, nData, pPage->pgno,
58713 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
58772 Pgno pgnoRoot;
58787 Pgno pgnoMove; /* Move a page here to make room for the root-page */
58830 Pgno iPtrPage = 0;
58925 Pgno pgno, /* Page number to clear */
58936 if( pgno>btreePagecount(pBt) ){
58940 rc = getAndInitPage(pBt, pgno, &pPage, 0);
58989 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
58996 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
59031 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
59052 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
59068 Pgno maxRootPgno;
59324 static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){
59332 static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){
59346 static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
59368 Pgno iChild, /* Child page number */
59370 Pgno iParent, /* Expected pointer map parent page number */
59375 Pgno iPtrmapParent;
59416 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
59434 Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
59490 int i, rc, depth, d2, pgno, cnt;
59509 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
59557 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
59569 pgno = get4byte(pCell);
59572 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
59575 d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
59584 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
59589 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
59592 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
59713 Pgno i;
60097 Pgno iNext; /* Page number of the next source page to copy */
60106 Pgno nRemaining; /* Number of pages left to copy */
60107 Pgno nPagecount; /* Total number of pages to copy */
60282 Pgno iSrcPg, /* Source database page to backup */
60340 Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
60461 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
60462 const Pgno iSrcPg = p->iNext; /* Source page number */
60477 if( p->iNext>(Pgno)nSrcPage ){
60544 Pgno iPg;
60563 for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
60585 const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
60719 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
71412 int pgno;
71414 rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
71416 assert( pgno==MASTER_ROOT+1 );
71420 rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, pKeyInfo, pCx->pCursor);
73064 int pgno;
73068 pgno = 0;
73080 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
73081 pOut->u.i = pgno;
