Lines Matching refs:pgno
8881 typedef u32 Pgno;
8901 #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
8963 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
8965 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
8972 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
9013 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
9021 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
9070 Pgno pgno; /* Page number for this page */
9128 SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
9137 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
9139 /* Remove all pages with pgno>x. Reset the cache if x==0 */
9140 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
11963 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
36353 if( p->pgno==1 ){
36439 Pgno pgno, /* Page number to obtain */
36449 assert( pgno>0 );
36468 pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
36493 pPg->pgno, pgno,
36503 pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
36516 pPgHdr->pgno = pgno;
36519 assert( pPgHdr->pgno==pgno );
36527 if( pgno==1 ){
36576 if( p->pgno==1 ){
36633 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
36637 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
36638 p->pgno = newPgno;
36646 ** Drop every cache entry whose page number is greater than "pgno". The
36648 ** other than page 1 with a page number greater than pgno.
36650 ** If there is a reference to page 1 and the pgno parameter passed to this
36654 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
36660 /* This routine never gets call with a positive pgno except right
36662 ** it must be that pgno==0.
36664 assert( p->pgno>0 );
36665 if( ALWAYS(p->pgno>pgno) ){
36670 if( pgno==0 && pCache->pPage1 ){
36672 pgno = 1;
36674 sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
36695 ** Merge two lists of pages connected by pDirty and in pgno order.
36702 if( pA->pgno<pB->pgno ){
36723 ** Sort the list of pages in accending order by pgno. Pages are
37341 unsigned int iLimit /* Drop pages with this pgno or larger */
38384 SQLITE_PRIVATE int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
38387 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
38394 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
38405 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
38875 Pgno nOrig; /* Original number of pages in file */
38876 Pgno iSubRec; /* Index of first record in sub-journal */
39066 Pgno dbSize; /* Number of pages in the database */
39067 Pgno dbOrigSize; /* dbSize before the current transaction */
39068 Pgno dbFileSize; /* Number of pages in the database file */
39069 Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
39093 Pgno mxPgno; /* Maximum allowed size of the database */
39105 void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
39419 Pgno pgno = pPg->pgno;
39424 if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
39435 return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
40077 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
40083 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
40115 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
40119 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
40125 if( pgno<=p->nOrig ){
40126 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
40531 Pgno pgno; /* The page number of a page in journal */
40561 rc = read32bits(jfd, *pOffset, &pgno);
40572 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
40576 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
40590 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
40596 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
40639 pPg = pager_lookup(pPager, pgno);
40644 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
40656 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
40660 if( pgno>pPager->dbFileSize ){
40661 pPager->dbFileSize = pgno;
40664 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
40665 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
40666 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
40688 rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
40733 if( pgno==1 ){
40738 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
40897 static int pager_truncate(Pager *pPager, Pgno nPage){
41037 Pgno mxPg = 0; /* Size of the original file in pages */
41235 Pgno pgno = pPg->pgno; /* Page number to read */
41251 rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
41254 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
41261 if( pgno==1 ){
41281 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
41285 IOTRACE(("PGIN %p %d\n", pPager, pgno));
41287 PAGERID(pPager), pgno, pager_pagehash(pPg)));
41327 static int pagerUndoCallback(void *pCtx, Pgno iPg){
41377 rc = pagerUndoCallback((void *)pPager, pList->pgno);
41396 Pgno nTruncate, /* Database size after this commit */
41409 assert( p->pgno < p->pDirty->pgno );
41421 if( p->pgno<=nTruncate ) ppNext = &p->pDirty;
41426 if( pList->pgno==1 ) pager_write_changecounter(pList);
41433 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
41487 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
41488 Pgno nPage; /* Value to return via *pnPage */
41515 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
41523 pPager->mxPgno = (Pgno)nPage;
41556 Pgno nPage; /* Size of the database file */
41946 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
42123 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
42138 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
42241 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
42242 return pPg->pgno;
42459 Pgno pgno = pList->pgno;
42469 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
42470 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
42474 if( pList->pgno==1 ) pager_write_changecounter(pList);
42477 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
42486 if( pgno==1 ){
42489 if( pgno>pPager->dbFileSize ){
42490 pPager->dbFileSize = pgno;
42494 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
42497 PAGERID(pPager), pgno, pager_pagehash(pList)));
42498 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
42502 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
42536 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
42555 || pPg->pgno>pPager->dbOrigSize
42566 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
42567 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
42568 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
42577 rc = addToSavepointBitvecs(pPager, pPg->pgno);
42675 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
42689 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
43070 Pgno nPage; /* Number of pages in database file */
43306 Pgno nPage = 0;
43371 ** Acquire a reference to page number pgno in pager pPager (a page
43403 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
43422 Pgno pgno, /* Page number to fetch */
43432 if( pgno==0 ){
43441 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
43451 assert( (*ppPage)->pgno==pgno );
43457 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
43470 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
43475 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
43476 if( pgno>pPager->mxPgno ){
43488 if( pgno<=pPager->dbOrigSize ){
43489 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
43492 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
43497 IOTRACE(("ZERO %p %d\n", pPager, pgno));
43533 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
43536 assert( pgno!=0 );
43539 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
43792 if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
43800 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
43803 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
43815 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
43822 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
43826 PAGERID(pPager), pPg->pgno,
43832 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
43835 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
43845 PAGERID(pPager), pPg->pgno,
43862 if( pPager->dbSize<pPg->pgno ){
43863 pPager->dbSize = pPg->pgno;
43887 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
43894 Pgno nPageCount; /* Total number of pages in database file */
43895 Pgno pg1; /* First page of the sector pPg is located on. */
43912 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
43915 if( pPg->pgno>nPageCount ){
43916 nPage = (pPg->pgno - pg1)+1;
43923 assert(pg1<=pPg->pgno);
43924 assert((pg1+nPage)>pPg->pgno);
43927 Pgno pg = pg1+ii;
43929 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
44001 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
44002 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
44287 Pgno i; /* Iterator variable */
44288 const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
44289 const Pgno dbSize = pPager->dbSize; /* Database image size */
44337 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
44749 void *(*xCodec)(void*,void*,Pgno,int),
44768 ** Move the page pPg to location pgno in the file.
44771 ** pgno (which we call pPgOld) though that page is allowed to be
44772 ** in cache. If the page previously located at pgno is not already
44792 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
44794 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
44796 Pgno origPgno; /* The original page number */
44826 ** subjournalPage() may need to allocate space to store pPg->pgno into
44838 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
44839 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
44841 /* If the journal needs to be sync()ed before page pPg->pgno can
44842 ** be written to, store pPg->pgno in local variable needSyncPgno.
44845 ** the journal needs to be sync()ed before database page pPg->pgno
44849 needSyncPgno = pPg->pgno;
44850 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
44854 /* If the cache contains a page with page-number pgno, remove it
44856 ** page pgno before the 'move' operation, it needs to be retained
44860 pPgOld = pager_lookup(pPager, pgno);
44873 origPgno = pPg->pgno;
44874 sqlite3PcacheMove(pPg, pgno);
45324 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
46037 u32 pgno; /* Page number of the frame */
46049 pgno = sqlite3Get4byte(&aFrame[0]);
46050 if( pgno==0 ){
46072 *piPage = pgno;
46491 u32 pgno; /* Database page number for frame */
46498 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
46500 rc = walIndexAppend(pWal, iFrame, pgno);
46672 u32 iMin; /* Result pgno must be greater than iMin */
46737 Pgno dbpage;
47630 Pgno pgno, /* Database page number to read data for */
47654 ** pgno. Each iteration of the following for() loop searches one
47671 ** (aPgno[iFrame]==pgno):
47691 for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
47693 if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
47711 if( walFramePgno(pWal, iTest)==pgno ){
47744 SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
47823 SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
47826 Pgno iMax = pWal->hdr.mxFrame;
47827 Pgno iFrame;
48029 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
48045 Pgno nTruncate, /* Database size after this commit */
48195 rc = walIndexAppend(pWal, iFrame, p->pgno);
48200 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
48732 Pgno pgno; /* Page number for this page */
48751 Pgno iTable; /* Root page of table */
48935 Pgno *aOverflow; /* Cache of overflow page locations */
48937 Pgno pgnoRoot; /* The root page of this tree */
49000 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
49001 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
49002 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
49005 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
49006 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
49007 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
49077 Pgno nPage; /* Number of pages in the database */
49487 Pgno iRoot, /* Root page of b-tree */
49492 Pgno iTab = 0;
49566 static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
49586 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
49658 Pgno iTable, u8 eLock){
49853 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
49887 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
49890 assert( pgno<=pBt->nPage );
49896 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
49897 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
49909 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
49911 return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
49980 static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
50099 ** Return 0 (not a valid page) for pgno==1 since there is
50103 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
50105 Pgno iPtrMap, ret;
50107 if( pgno<2 ) return 0;
50109 iPtrMap = (pgno-2)/nPagesPerMapPage;
50121 ** so that it maps to type 'eType' and parent page number 'pgno'.
50127 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
50130 Pgno iPtrmap; /* The pointer map page number */
50179 static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
50413 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
50414 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
50711 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
50747 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
50861 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
50892 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
50897 pPage->pgno = pgno;
50898 pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
50915 Pgno pgno, /* Number of the page to fetch */
50923 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
50925 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
50934 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
50937 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
50939 return btreePageFromDbPage(pDbPage, pgno, pBt);
50948 static Pgno btreePagecount(BtShared *pBt){
50967 Pgno pgno, /* Number of the page to get */
50973 if( pgno>btreePagecount(pBt) ){
50976 rc = btreeGetPage(pBt, pgno, ppPage, 0);
50985 testcase( pgno==0 );
50986 assert( pgno!=0 || rc==SQLITE_CORRUPT );
51191 assert( sizeof(Pgno)==4 );
52059 Pgno pgno = pPage->pgno;
52074 Pgno childPgno = get4byte(pCell);
52075 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
52080 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
52081 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
52103 static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
52159 ** the journal needs to be sync()ed before database page pDbPage->pgno
52167 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
52168 Pgno iFreePage, /* The location to move pDbPage to */
52172 Pgno iDbPage = pDbPage->pgno;
52188 pDbPage->pgno = iFreePage;
52204 Pgno nextOvfl = get4byte(pDbPage->aData);
52237 static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
52257 static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
52258 Pgno nFreeList; /* Number of pages still on the free-list */
52266 Pgno iPtrPage;
52288 Pgno iFreePg;
52298 Pgno iFreePg; /* Index of free page to move pLastPg to */
52404 Pgno nFin; /* Number of pages in database after autovacuuming */
52405 Pgno nFree; /* Number of pages on the freelist initially */
52406 Pgno nPtrmap; /* Number of PtrMap pages to be freed */
52407 Pgno iFree; /* The next page to be freed */
52409 Pgno nOrig; /* Database size before freeing */
52855 pCur->pgnoRoot = (Pgno)iTable;
53093 Pgno ovfl, /* Current overflow page number */
53095 Pgno *pPgnoNext /* OUT: Next overflow page number */
53097 Pgno next = 0;
53112 Pgno pgno;
53113 Pgno iGuess = ovfl+1;
53121 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
53122 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
53254 Pgno nextPage;
53268 pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
53557 Pgno iChild){
53592 pCur->apPage[pCur->iPage]->pgno
53676 assert( pRoot->pgno==pCur->pgnoRoot );
53685 Pgno subpage;
53686 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
53704 Pgno pgno;
53712 pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
53713 rc = moveToChild(pCur, pgno);
53729 Pgno pgno;
53736 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
53738 rc = moveToChild(pCur, pgno);
53883 Pgno chldPg;
54194 Pgno *pPgno,
54195 Pgno nearby,
54204 Pgno mxPage; /* Total size of the database file */
54216 Pgno iTrunk;
54315 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
54351 Pgno iPage;
54381 *pPgno, closest+1, k, pTrunk->pgno, n-1));
54472 static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
54474 Pgno iTrunk = 0; /* Page number of free-list trunk page */
54482 assert( !pMemPage || pMemPage->pgno==iPage );
54563 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54584 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
54596 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
54606 Pgno ovflPgno;
54625 Pgno iNext = 0;
54694 Pgno pgnoOvfl = 0;
54743 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
54898 Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
55066 Pgno pgnoNew; /* Page number of pNew */
55103 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
55130 0, pPage->pgno, &rc);
55152 Pgno n;
55165 Pgno ovfl = get4byte(&z[info.iOverflow]);
55167 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
55170 Pgno child = get4byte(z);
55172 assert( n==pPage->pgno && e==PTRMAP_BTREE );
55176 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
55178 assert( n==pPage->pgno && e==PTRMAP_BTREE );
55208 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
55315 Pgno pgno; /* Temp var to store a page number in */
55322 TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
55368 pgno = get4byte(pRight);
55370 rc = getAndInitPage(pBt, pgno, &apOld[i]);
55380 pgno = get4byte(apDiv[i]);
55385 pgno = get4byte(apDiv[i]);
55591 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
55595 apOld[0]->pgno,
55596 nOld>=2 ? apOld[1]->pgno : 0,
55597 nOld>=3 ? apOld[2]->pgno : 0
55603 if( apOld[0]->pgno<=1 ){
55618 rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
55625 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
55658 int minV = apNew[i]->pgno;
55661 if( apNew[j]->pgno<(unsigned)minV ){
55663 minV = apNew[j]->pgno;
55674 apNew[0]->pgno, szNew[0],
55675 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
55676 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
55677 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
55678 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
55681 put4byte(pRight, apNew[nNew-1]->pgno);
55747 insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
55863 if( isDivider || pOld->pgno!=pNew->pgno ){
55865 ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
55876 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
55932 Pgno pgnoChild = 0; /* Page number of the new child page */
55944 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
55947 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
55959 TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
56029 && pParent->pgno!=1
56187 pCur->pgnoRoot, nKey, nData, pPage->pgno,
56331 Pgno n = pCur->apPage[iCellDepth+1]->pgno;
56390 Pgno pgnoRoot;
56405 Pgno pgnoMove; /* Move a page here to make room for the root-page */
56448 Pgno iPtrPage = 0;
56536 Pgno pgno, /* Page number to clear */
56546 if( pgno>btreePagecount(pBt) ){
56550 rc = getAndInitPage(pBt, pgno, &pPage);
56603 rc = saveAllCursors(pBt, (Pgno)iTable, 0);
56605 rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
56631 static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
56652 rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
56668 Pgno maxRootPgno;
56927 static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
56948 Pgno iChild, /* Child page number */
56950 Pgno iParent, /* Expected pointer map parent page number */
56955 Pgno iPtrmapParent;
56996 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
57014 Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
57070 int i, rc, depth, d2, pgno, cnt;
57089 if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
57137 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
57149 pgno = get4byte(pCell);
57152 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57155 d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
57164 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
57169 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57172 checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
57293 Pgno i;
57667 Pgno iNext; /* Page number of the next source page to copy */
57676 Pgno nRemaining; /* Number of pages left to copy */
57677 Pgno nPagecount; /* Total number of pages to copy */
57850 static int backupOnePage(sqlite3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
57902 Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
58020 for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
58021 const Pgno iSrcPg = p->iNext; /* Source page number */
58035 if( p->iNext>(Pgno)nSrcPage ){
58121 const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
58254 SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
65296 int pgno;
68120 int pgno;
68122 rc = sqlite3BtreeCreateTable(u.ay.pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
68124 assert( pgno==MASTER_ROOT+1 );
68125 rc = sqlite3BtreeCursor(u.ay.pCx->pBt, pgno, 1,
69721 int pgno;
69726 u.bx.pgno = 0;
69737 rc = sqlite3BtreeCreateTable(u.bx.pDb->pBt, &u.bx.pgno, u.bx.flags);
69738 pOut->u.i = u.bx.pgno;
