Lines Matching refs:pgno
15317 SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
15318 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
15368 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno);
16509 PgHdr *pDirty; /* Transient list of dirty sorted by pgno */
16511 Pgno pgno; /* Page number for this page */
16587 /* Remove all pages with pgno>x. Reset the cache if x==0 */
36336 unsigned int pgno;
36351 pgno = 1 + iOfst/iAmt;
36353 pgno = 1;
36355 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
36421 unsigned int pgno;
36429 pgno = 1 + iOfst/iAmt;
36430 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
36461 unsigned int pgno, pgnoMax;
36463 pgno = 1 + size/pFile->szPage;
36465 while( pgno<=pgnoMax ){
36466 sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);
36468 pgno++;
52081 int pgno;
52082 for(pgno=1; pgno<=nPage; pgno++){
52084 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
52085 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
52739 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
52796 pPage->pgno));
52863 pcacheTrace(("%p.UNPIN %d\n", p->pCache, p->pgno));
53001 Pgno pgno, /* Page number to obtain */
53023 pRes = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
53024 pcacheTrace(("%p.FETCH %d%s (result: %p) ",pCache,pgno,
53026 pcachePageTrace(pgno, pRes);
53043 Pgno pgno, /* Page number to obtain */
53072 pPg->pgno, pgno,
53076 pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
53084 *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
53099 Pgno pgno, /* Page number obtained */
53112 pPgHdr->pgno = pgno;
53114 return sqlite3PcacheFetchFinish(pCache,pgno,pPage);
53125 Pgno pgno, /* Page number obtained */
53134 return pcacheFetchFinishWithInit(pCache, pgno, pPage);
53195 pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno));
53215 pcacheTrace(("%p.CLEAN %d\n",p->pCache,p->pgno));
53265 pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
53274 sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
53275 p->pgno = newPgno;
53283 ** Drop every cache entry whose page number is greater than "pgno". The
53285 ** other than page 1 with a page number greater than pgno.
53287 ** If there is a reference to page 1 and the pgno parameter passed to this
53291 SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
53295 pcacheTrace(("%p.TRUNCATE %d\n",pCache,pgno));
53298 /* This routine never gets call with a positive pgno except right
53300 ** it must be that pgno==0.
53302 assert( p->pgno>0 );
53303 if( p->pgno>pgno ){
53308 if( pgno==0 && pCache->nRefSum ){
53314 pgno = 1;
53317 sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
53338 ** Merge two lists of pages connected by pDirty and in pgno order.
53346 if( pA->pgno<pB->pgno ){
53368 ** Sort the list of pages in accending order by pgno. Pages are
54182 unsigned int iLimit /* Drop pages with this pgno or larger */
56309 ** Return true if page pgno can be read directly from the database file
56316 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
56326 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
56579 Pgno pgno = pPg->pgno;
56583 if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){
56598 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
57292 ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
57296 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
57302 if( pgno<=p->nOrig ){
57303 rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
57785 Pgno pgno; /* The page number of a page in journal */
57820 rc = read32bits(jfd, *pOffset, &pgno);
57831 if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){
57835 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
57849 if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
57855 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
57897 pPg = sqlite3PagerLookup(pPager, pgno);
57902 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
57914 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
57926 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT, aData);
57928 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT);
57933 if( pgno>pPager->dbFileSize ){
57934 pPager->dbFileSize = pgno;
57939 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT);
57940 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
57941 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT,aData);
57944 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
57966 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
57991 if( pgno==1 ){
57997 if( jrnlEnc ){ CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM_BKPT); }
58534 u32 iFrame = 0; /* Frame of WAL containing pgno */
58540 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
58548 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
58555 if( pPg->pgno==1 ){
58575 CODEC1(pPager, pPg->pData, pPg->pgno, 3, rc = SQLITE_NOMEM_BKPT);
58579 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
58581 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
58673 rc = pagerUndoCallback((void *)pPager, pList->pgno);
58704 assert( p->pgno < p->pDirty->pgno );
58717 if( p->pgno<=nTruncate ){
58728 if( pList->pgno==1 ) pager_write_changecounter(pList);
58734 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
59489 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
59490 Pgno pgno = pPg->pgno;
59494 assert( p->nOrig<pgno || sqlite3BitvecTestNotNull(p->pInSavepoint,pgno) );
59560 ** Obtain a reference to a memory mapped page object for page number pgno.
59571 Pgno pgno, /* Page number */
59586 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
59601 p->pgno = pgno;
59620 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
59741 return pPg->pgno;
59954 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
59962 Pgno pgno = pList->pgno;
59972 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
59973 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
59977 if( pList->pgno==1 ) pager_write_changecounter(pList);
59980 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM_BKPT, pData);
59989 if( pgno==1 ){
59992 if( pgno>pPager->dbFileSize ){
59993 pPager->dbFileSize = pgno;
59998 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
60001 PAGERID(pPager), pgno, pager_pagehash(pList)));
60002 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
60005 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
60040 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
60059 || pPg->pgno>pPager->dbOrigSize
60072 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
60076 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
60077 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
60086 rc = addToSavepointBitvecs(pPager, pPg->pgno);
60184 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
61002 ** page with page number pgno. If the requested reference is
61040 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
61059 Pgno pgno, /* Page number to fetch */
61073 if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
61074 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
61077 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
61084 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
61086 assert( pPg->pgno==pgno );
61093 assert( pgno!=PAGER_SJ_PGNO(pPager) );
61104 if( pgno==PAGER_SJ_PGNO(pPager) ){
61112 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
61113 if( pgno>pPager->mxPgno ){
61125 if( pgno<=pPager->dbOrigSize ){
61126 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
61129 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
61134 IOTRACE(("ZERO %p %d\n", pPager, pgno));
61161 Pgno pgno, /* Page number to fetch */
61173 const int bMmapOk = (pgno>1
61182 /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here
61183 ** allows the compiler optimizer to reuse the results of the "pgno>1"
61184 ** test in the previous statement, and avoid testing pgno==0 in the
61185 ** common case where pgno is large. */
61186 if( pgno<=1 && pgno==0 ){
61195 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
61204 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
61208 pPg = sqlite3PagerLookup(pPager, pgno);
61211 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
61213 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
61226 return getPageNormal(pPager, pgno, ppPage, flags);
61233 Pgno pgno, /* Page number to fetch */
61237 UNUSED_PARAMETER(pgno);
61249 Pgno pgno, /* Page number to fetch */
61253 /* printf("PAGE %u\n", pgno); fflush(stdout); */
61254 return pPager->xGet(pPager, pgno, ppPage, flags);
61268 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
61271 assert( pgno!=0 );
61273 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
61276 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
61295 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
61309 assert( pPg->pgno==1 );
61508 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
61511 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2);
61523 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
61530 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
61534 PAGERID(pPager), pPg->pgno,
61540 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
61543 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
61597 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
61600 if( pPg->pgno<=pPager->dbOrigSize ){
61610 PAGERID(pPager), pPg->pgno,
61630 if( pPager->dbSize<pPg->pgno ){
61631 pPager->dbSize = pPg->pgno;
61669 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
61672 if( pPg->pgno>nPageCount ){
61673 nPage = (pPg->pgno - pg1)+1;
61680 assert(pg1<=pPg->pgno);
61681 assert((pg1+nPage)>pPg->pgno);
61686 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
61746 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
61793 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
61794 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
62664 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
62672 ** Move the page pPg to location pgno in the file.
62675 ** pgno (which we call pPgOld) though that page is allowed to be
62676 ** in cache. If the page previously located at pgno is not already
62696 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
62698 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
62731 ** subjournalPage() may need to allocate space to store pPg->pgno into
62742 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
62743 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
62745 /* If the journal needs to be sync()ed before page pPg->pgno can
62746 ** be written to, store pPg->pgno in local variable needSyncPgno.
62749 ** the journal needs to be sync()ed before database page pPg->pgno
62753 needSyncPgno = pPg->pgno;
62755 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
62759 /* If the cache contains a page with page-number pgno, remove it
62761 ** page pgno before the 'move' operation, it needs to be retained
62765 pPgOld = sqlite3PagerLookup(pPager, pgno);
62782 origPgno = pPg->pgno;
62783 sqlite3PcacheMove(pPg, pgno);
62835 assert( pPg->pgno!=iNew );
64223 u32 pgno; /* Page number of the frame */
64235 pgno = sqlite3Get4byte(&aFrame[0]);
64236 if( pgno==0 ){
64258 *piPage = pgno;
64695 u32 pgno; /* Database page number for frame */
64701 isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
64703 rc = walIndexAppend(pWal, iFrame, pgno);
64956 u32 iMin; /* Result pgno must be greater than iMin */
65991 u32 pgno; /* Database page number for frame */
65997 if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
66329 u32 pgno; /* Page number in db file */
66336 pgno = sLoc.aPgno[i-sLoc.iZero-1];
66337 iDbOff = (i64)(pgno-1) * szPage;
66497 ** Search the wal file for page pgno. If found, set *piRead to the frame that
66498 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
66506 Pgno pgno, /* Database page number to read data for */
66529 ** pgno. Each iteration of the following for() loop searches one
66546 ** (aPgno[iFrame]==pgno):
66566 iKey = walHash(pgno);
66569 if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
66590 if( walFramePgno(pWal, iTest)==pgno ){
66907 if( pPage->pgno==1 ){
66916 walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
67090 VVA_ONLY(rc =) sqlite3WalFindFrame(pWal, p->pgno, &iWrite);
67183 rc = walIndexAppend(pWal, iFrame, p->pgno);
67189 rc = walIndexAppend(pWal, iFrame, pLast->pgno);
67843 Pgno pgno; /* Page number for this page */
68181 ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
68182 ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
68183 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
68186 #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
68187 #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
68188 #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
68758 (int)p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
68769 # define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno)
69187 ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
69221 static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
69224 assert( pgno<=pBt->nPage );
69230 if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
69231 rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
69243 static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
69245 return p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTestNotNull(p, pgno));
69585 ** Return 0 (not a valid page) for pgno==1 since there is
69589 static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
69593 if( pgno<2 ) return 0;
69595 iPtrMap = (pgno-2)/nPagesPerMapPage;
69607 ** so that it maps to type 'eType' and parent page number 'pgno'.
70095 ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
70529 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
70578 pPage->pgno,
70615 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
70732 assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
70784 assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno || CORRUPT_DB );
70815 static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
70817 if( pgno!=pPage->pgno ){
70821 pPage->pgno = pgno;
70822 pPage->hdrOffset = pgno==1 ? 100 : 0;
70841 Pgno pgno, /* Number of the page to fetch */
70850 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
70852 *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
70861 static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
70864 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
70866 return btreePageFromDbPage(pDbPage, pgno, pBt);
70898 Pgno pgno, /* Number of the page to get */
70910 if( pgno>btreePagecount(pBt) ){
70914 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
70920 btreePageFromDbPage(pDbPage, pgno, pBt);
70926 assert( (*ppPage)->pgno==pgno || CORRUPT_DB );
70932 rc = SQLITE_CORRUPT_PGNO(pgno);
70944 testcase( pgno==0 );
70945 assert( pgno!=0 || rc!=SQLITE_OK );
70989 Pgno pgno, /* Number of the page to fetch */
70993 int rc = btreeGetPage(pBt, pgno, ppPage, flags);
72312 Pgno pgno = pPage->pgno;
72326 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
72332 ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
72412 ** the journal needs to be sync()ed before database page pDbPage->pgno
72425 Pgno iDbPage = pDbPage->pgno;
72442 pDbPage->pgno = iFreePage;
73403 return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) +
73483 Pgno pgno;
73492 rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
73493 if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
73950 pCur->pPage->pgno
74024 assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB );
74050 if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
74069 Pgno pgno;
74077 pgno = get4byte(findCell(pPage, pCur->ix));
74078 rc = moveToChild(pCur, pgno);
74094 Pgno pgno;
74101 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
74103 rc = moveToChild(pCur, pgno);
74959 rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1);
75098 *pPgno, closest+1, k, pTrunk->pgno, n-1));
75211 assert( !pMemPage || pMemPage->pgno==iPage );
75304 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
75325 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
75337 *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
75518 ** pPrior Where to write the pgno of the first overflow page
76316 ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
76344 0, pPage->pgno, &rc);
76382 assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
76387 assert( n==pPage->pgno && e==PTRMAP_BTREE );
76393 assert( n==pPage->pgno && e==PTRMAP_BTREE );
76423 int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
76528 Pgno pgno; /* Temp var to store a page number in */
76583 pgno = get4byte(pRight);
76586 rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0);
76604 pgno = get4byte(apDiv[i]);
76609 pgno = get4byte(apDiv[i]);
76905 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB);
76907 apOld[0]->pgno, apOld[0]->nCell,
76908 nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0,
76909 nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0
76931 rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
76940 ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
76961 aPgno[i] = apNew[i]->pgno;
76968 if( apNew[j]->pgno < apNew[iB]->pgno ) iB = j;
76977 Pgno pgnoA = apNew[i]->pgno;
76978 Pgno pgnoB = apNew[iB]->pgno;
76985 apNew[i]->pgno = pgnoB;
76986 apNew[iB]->pgno = pgnoA;
76992 apNew[0]->pgno, szNew[0], cntNew[0],
76993 nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
76995 nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
76997 nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
76999 nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0,
77006 put4byte(pRight, apNew[nNew-1]->pgno);
77060 || pNew->pgno!=aPgno[iOld]
77064 ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
77129 insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);
77231 ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
77306 rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
77309 ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
77321 TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
77430 && pParent->pgno!=1
77798 pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
77812 ptrmapPut(pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);
78019 ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);
78179 n = pCur->apPage[iCellDepth+1]->pgno;
78181 n = pCur->pPage->pgno;
78425 Pgno pgno, /* Page number to clear */
78437 if( pgno>btreePagecount(pBt) ){
78440 rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
78443 && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
79037 int pgno; /* Page number */
79109 pgno = get4byte(&data[hdr+8]);
79113 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
79116 depth = checkTreePage(pCheck, pgno, &maxKey, maxKey);
79175 pgno = get4byte(pCell);
79178 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage);
79181 d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey);
97123 Pgno pgno;
97128 pgno = 0;
97135 rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
97137 pOut->u.i = pgno;
177210 SQLITE_PRIVATE int sqlite3CorruptPgnoError(int lineno, Pgno pgno){
177212 sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno);
215109 ** SELECT data FROM sqlite_dbpage('aux1') WHERE pgno=123;
215130 int pgno; /* Current page number */
215165 "CREATE TABLE x(pgno INTEGER PRIMARY KEY, data BLOB, schema HIDDEN)");
215193 ** 1 schema=main, pgno=?1
215195 ** 3 schema=?1, pgno=?2
215225 /* Check for constraints against pgno */
215262 pCsr->pgno = -1;
215285 pCsr->pgno++;
215291 return pCsr->pgno > pCsr->mxPgno;
215298 ** 1 schema=main, pgno=?1
215300 ** 3 schema=?1, pgno=?2
215316 pCsr->pgno = 1;
215335 pCsr->pgno = sqlite3_value_int(argv[idxNum>>1]);
215336 if( pCsr->pgno<1 || pCsr->pgno>pCsr->mxPgno ){
215337 pCsr->pgno = 1;
215340 pCsr->mxPgno = pCsr->pgno;
215343 assert( pCsr->pgno==1 );
215358 case 0: { /* pgno */
215359 sqlite3_result_int(ctx, pCsr->pgno);
215364 if( pCsr->pgno==((PENDING_BYTE/pCsr->szPage)+1) ){
215369 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
215389 *pRowid = pCsr->pgno;
215400 Pgno pgno;
215418 pgno = sqlite3_value_int(argv[0]);
215419 if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){
215430 if( pgno<1 || pBt==0 || pgno>sqlite3BtreeLastPage(pBt) ){
215442 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);
230237 #define fts5_dri(segid, dlidx, height, pgno) ( \
230241 ((i64)(pgno)) \
230244 #define FTS5_SEGMENT_ROWID(segid, pgno) fts5_dri(segid, 0, 0, pgno)
230245 #define FTS5_DLIDX_ROWID(segid, height, pgno) fts5_dri(segid, 1, height, pgno)
230350 int pgno; /* Page number for this page */
230357 int pgno; /* Page number for this page */
232192 int pgno;
232197 for(pgno=pIter->iLeafPgno+1; !p->rc && pgno<=pSeg->pgnoLast; pgno++){
232198 i64 iAbs = FTS5_SEGMENT_ROWID(pSeg->iSegid, pgno);
232206 pgnoLast = pgno;
232417 "SELECT pgno FROM '%q'.'%q_idx' WHERE "
233134 int pgno = pSeg->iLeafPgno;
233141 pgnoSave = pgno+1;
233154 pgno++;
233155 pData = fts5LeafRead(p, FTS5_SEGMENT_ROWID(pSeg->pSeg->iSegid, pgno));
233159 if( pgno==pgnoSave ){
233743 assert( pDlidx->pgno!=0 );
233745 FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
233845 pWriter->iBtPage = pWriter->writer.pgno;
233903 FTS5_DLIDX_ROWID(pWriter->iSegid, i, pDlidx->pgno),
233912 pDlidx[1].pgno = pDlidx->pgno;
233914 sqlite3Fts5BufferAppendVarint(&p->rc, &pDlidx[1].buf, pDlidx->pgno);
233922 pDlidx->pgno++;
233930 i64 iPgno = (i==0 ? pWriter->writer.pgno : pDlidx[-1].pgno);
233964 iRowid = FTS5_SEGMENT_ROWID(pWriter->iSegid, pPage->pgno);
233972 pPage->pgno++;
234024 if( pPage->pgno!=1 ){
234064 pWriter->aDlidx[0].pgno = pPage->pgno;
234147 assert( pLeaf->pgno>=1 );
234151 *pnLeaf = pLeaf->pgno-1;
234152 if( pLeaf->pgno>1 ){
234178 pWriter->writer.pgno = 1;
234192 "INSERT INTO '%q'.'%q_idx'(segid,term,pgno) VALUES(?,?,?)",
234324 writer.writer.pgno = pSeg->pgnoLast+1;
235429 "segid, term, pgno, PRIMARY KEY(segid, term)",
235819 ** Instead, it tests that the same set of pgno/rowid combinations are
235837 int pgno = fts5DlidxIterPgno(pDlidx);
235838 assert( pgno>iLeaf );
235839 cksum1 += iRowid + ((i64)pgno<<32);
235849 int pgno = fts5DlidxIterPgno(pDlidx);
235851 cksum2 += iRowid + ((i64)pgno<<32);
236099 "SELECT segid, term, (pgno>>1), (pgno&1) FROM %Q.'%q_idx' WHERE segid=%d "
236360 sqlite3Fts5BufferAppendPrintf(pRc, pBuf, "{%ssegid=%d h=%d pgno=%d}",
236767 int segid, pgno;
236770 "should be: fts5_rowid('segment', segid, pgno))", -1
236774 pgno = sqlite3_value_int(apVal[2]);
236775 iRowid = FTS5_SEGMENT_ROWID(segid, pgno);
245488 CODEC_STATIC int sqlite3CodecHmac(KeyContext *ctx, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245497 sqlite3CodecTransPgno(pgno, pgnoBuffer);
245510 CODEC_STATIC int sqlite3CodecCheckHmac(KeyContext *ctx, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *expectResult){
245517 rc = sqlite3CodecHmac(ctx, pgno, bufferSize, input, buffer);
245527 rc = sqlite3CodecHmac(ctx, pgno, bufferSize, input, output);
245538 CODEC_STATIC int sqlite3CodecEncryptData(CodecContext *ctx, OperateContext whichKey, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245579 rc = sqlite3CodecHmac(keyCtx, pgno, inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize, output, output + inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize);
245586 CODEC_STATIC int sqlite3CodecDecryptData(CodecContext *ctx, OperateContext whichKey, Pgno pgno, int bufferSize, unsigned char *input, unsigned char *output){
245618 if(sqlite3CodecCheckHmac(keyCtx, pgno, inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize, input, input + inputBuffer.bufferSize + keyCtx->codecConst.initVectorSize)){
245620 pgno, keyCtx->codecConst.hmacAlgo, keyCtx->codecConst.kdfAlgo, keyCtx->codecConst.cipherPageSize);
245637 void* sqlite3Codec(void *ctx, void *data, Pgno pgno, int mode){
245646 if(pgno == 1){
245654 if(pgno == 1){
245661 rc = sqlite3CodecDecryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245669 if(pgno == 1){
245676 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_WRITE, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245684 if(pgno == 1){
245691 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245804 Pgno pgno;
245827 for(pgno = 1; pgno <= (unsigned int)pageCount; pgno++){
245828 if(PAGER_SJ_PGNO(pPager) != pgno){
245829 rc = sqlite3PagerGet(pPager, pgno, &page, 0);
245835 sqlite3_log(SQLITE_WARNING, "sqlite3_rekey_v2: error when writing page %d: errno = %d.", pgno, rc);
245838 sqlite3_log(SQLITE_WARNING, "sqlite3_rekey_v2: error when reading page %d: errno = %d.", pgno, rc);