Lines Matching full:ppg
54288 PgHdr *pPg;
54294 pPg = (PgHdr*)pLower->pExtra;
54295 printf("%3d: nRef %2lld flgs %02x data ", i, pPg->nRef, pPg->flags);
54298 printf(" ptr %p\n", pPg);
54325 ** Return 1 if pPg is on the dirty list for pCache. Return 0 if not.
54329 static int pageOnDirtyList(PCache *pCache, PgHdr *pPg){
54332 if( p==pPg ) return 1;
54336 static int pageNotOnDirtyList(PCache *pCache, PgHdr *pPg){
54339 if( p==pPg ) return 0;
54355 ** assert( sqlite3PcachePageSanity(pPg) );
54358 SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
54360 assert( pPg!=0 );
54361 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
54362 pCache = pPg->pCache;
54364 if( pPg->flags & PGHDR_CLEAN ){
54365 assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */
54366 assert( pageNotOnDirtyList(pCache, pPg) );/* CLEAN pages not on dirtylist */
54368 assert( (pPg->flags & PGHDR_DIRTY)!=0 );/* If not CLEAN must be DIRTY */
54369 assert( pPg->pDirtyNext==0 || pPg->pDirtyNext->pDirtyPrev==pPg );
54370 assert( pPg->pDirtyPrev==0 || pPg->pDirtyPrev->pDirtyNext==pPg );
54371 assert( pPg->pDirtyPrev!=0 || pCache->pDirty==pPg );
54372 assert( pageOnDirtyList(pCache, pPg) );
54375 if( pPg->flags & PGHDR_WRITEABLE ){
54376 assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */
54668 PgHdr *pPg;
54681 for(pPg=pCache->pSynced;
54682 pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
54683 pPg=pPg->pDirtyPrev
54685 pCache->pSynced = pPg;
54686 if( !pPg ){
54687 for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
54689 if( pPg ){
54694 pPg->pgno, pgno,
54698 pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
54699 rc = pCache->xStress(pCache->pStress, pPg);
55590 void *pPg;
55608 pPg = pcache1Alloc(pCache->szAlloc);
55613 if( pPg==0 ) return 0;
55614 p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
55615 p->page.pBuf = pPg;
56236 sqlite3_pcache_page *pPg,
56240 PgHdr1 *pPage = (PgHdr1 *)pPg;
56271 sqlite3_pcache_page *pPg,
56276 PgHdr1 *pPage = (PgHdr1 *)pPg;
56285 assert( pcache1FetchNoMutex(p, iOld, 0)==pPage ); /* pPg really is iOld */
58167 ** Return true if it is necessary to write page *pPg into the sub-journal.
58175 static int subjRequiresPage(PgHdr *pPg){
58176 Pager *pPager = pPg->pPager;
58178 Pgno pgno = pPg->pgno;
58196 static int pageInJournal(Pager *pPager, PgHdr *pPg){
58197 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
58370 static void checkPage(PgHdr *pPg){
58371 Pager *pPager = pPg->pPager;
58373 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
59395 PgHdr *pPg; /* An existing page in the cache */
59501 pPg = 0;
59503 pPg = sqlite3PagerLookup(pPager, pgno);
59505 assert( pPg || !MEMDB );
59506 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
59514 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
59521 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
59538 }else if( !isMainJrnl && pPg==0 ){
59558 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
59562 sqlite3PcacheMakeDirty(pPg);
59564 if( pPg ){
59572 pData = pPg->pData;
59574 pPager->xReiniter(pPg);
59575 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
59579 pager_set_pagehash(pPg);
59586 sqlite3PcacheRelease(pPg);
60107 ** Read the content for page pPg out of the database file (or out of
60109 ** pPg->pData. A shared lock or greater must be held on the database
60118 static int readDbPage(PgHdr *pPg){
60119 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
60129 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
60133 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
60137 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
60138 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
60144 if( pPg->pgno==1 ){
60160 u8 *dbFileVers = &((u8*)pPg->pData)[24];
60166 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
60168 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
60181 static void pager_write_changecounter(PgHdr *pPg){
60183 if( NEVER(pPg==0) ) return;
60186 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
60187 put32bits(((char*)pPg->pData)+24, change_counter);
60192 put32bits(((char*)pPg->pData)+92, change_counter);
60193 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
60212 PgHdr *pPg;
60215 pPg = sqlite3PagerLookup(pPager, iPg);
60216 if( pPg ){
60217 if( sqlite3PcachePageRefcount(pPg)==1 ){
60218 sqlite3PcacheDrop(pPg);
60220 rc = readDbPage(pPg);
60222 pPager->xReiniter(pPg);
60224 sqlite3PagerUnrefNotNull(pPg);
61071 static void assertTruncateConstraintCb(PgHdr *pPg){
61072 Pager *pPager = pPg->pPager;
61073 assert( pPg->flags&PGHDR_DIRTY );
61074 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
61075 Pgno pgno = pPg->pgno;
61077 for(i=0; i<pPg->pPager->nSavepoint; i++){
61195 ** Release a reference to page pPg. pPg must have been returned by an
61198 static void pagerReleaseMapPage(PgHdr *pPg){
61199 Pager *pPager = pPg->pPager;
61201 pPg->pDirty = pPager->pMmapFreelist;
61202 pPager->pMmapFreelist = pPg;
61205 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
61318 ** Return the page number for page pPg.
61320 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
61321 return pPg->pgno;
61326 ** Increment the reference count for page pPg.
61328 SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){
61329 sqlite3PcacheRef(pPg);
61617 ** Append a record of the current state of page pPg to the sub-journal.
61619 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
61627 static int subjournalPage(PgHdr *pPg){
61629 Pager *pPager = pPg->pPager;
61637 || pageInJournal(pPager, pPg)
61638 || pPg->pgno>pPager->dbOrigSize
61645 void *pData = pPg->pData;
61649 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
61650 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
61659 rc = addToSavepointBitvecs(pPager, pPg->pgno);
61663 static int subjournalPageIfRequired(PgHdr *pPg){
61664 if( subjRequiresPage(pPg) ){
61665 return subjournalPage(pPg);
61680 ** The job of this function is to make pPg clean by writing its contents
61690 static int pagerStress(void *p, PgHdr *pPg){
61694 assert( pPg->pPager==pPager );
61695 assert( pPg->flags&PGHDR_DIRTY );
61719 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
61725 pPg->pDirty = 0;
61728 rc = subjournalPageIfRequired(pPg);
61730 rc = pagerWalFrames(pPager, pPg, 0, 0);
61742 if( pPg->flags&PGHDR_NEED_SYNC
61750 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
61751 rc = pager_write_pagelist(pPager, pPg);
61757 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
61758 sqlite3PcacheMakeClean(pPg);
62622 PgHdr *pPg;
62634 pPg = 0;
62642 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
62643 assert( pPg==(*ppPage) );
62644 assert( pPg->pgno==pgno );
62645 assert( pPg->pPager==pPager || pPg->pPager==0 );
62648 if( pPg->pPager && !noContent ){
62667 pPg->pPager = pPager;
62674 sqlite3PcacheRelease(pPg);
62675 pPg = 0;
62695 memset(pPg->pData, 0, pPager->pageSize);
62698 assert( pPg->pPager==pPager );
62700 rc = readDbPage(pPg);
62705 pager_set_pagehash(pPg);
62711 if( pPg ){
62712 sqlite3PcacheDrop(pPg);
62728 PgHdr *pPg = 0;
62767 pPg = sqlite3PagerLookup(pPager, pgno);
62769 if( pPg==0 ){
62770 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
62774 if( pPg ){
62776 *ppPage = pPg;
62864 SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
62865 TESTONLY( Pager *pPager = pPg->pPager; )
62866 assert( pPg!=0 );
62867 if( pPg->flags & PGHDR_MMAP ){
62868 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
62869 pagerReleaseMapPage(pPg);
62871 sqlite3PcacheRelease(pPg);
62876 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
62877 if( pPg ) sqlite3PagerUnrefNotNull(pPg);
62879 SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){
62881 assert( pPg!=0 );
62882 assert( pPg->pgno==1 );
62883 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
62884 pPager = pPg->pPager;
62885 sqlite3PcacheRelease(pPg);
63069 ** Write page pPg onto the end of the rollback journal.
63071 static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
63072 Pager *pPager = pPg->pPager;
63081 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
63084 pData2 = pPg->pData;
63094 pPg->flags |= PGHDR_NEED_SYNC;
63096 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
63103 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
63107 PAGERID(pPager), pPg->pgno,
63108 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
63113 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
63116 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
63128 static int pager_write(PgHdr *pPg){
63129 Pager *pPager = pPg->pPager;
63143 CHECK_PAGE(pPg);
63162 sqlite3PcacheMakeDirty(pPg);
63170 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
63173 if( pPg->pgno<=pPager->dbOrigSize ){
63174 rc = pagerAddPageToRollbackJournal(pPg);
63180 pPg->flags |= PGHDR_NEED_SYNC;
63183 PAGERID(pPager), pPg->pgno,
63184 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
63193 pPg->flags |= PGHDR_WRITEABLE;
63199 rc = subjournalPageIfRequired(pPg);
63203 if( pPager->dbSize<pPg->pgno ){
63204 pPager->dbSize = pPg->pgno;
63220 static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
63223 Pgno pg1; /* First page of the sector pPg is located on. */
63227 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
63240 ** of the first page of the sector pPg is located on.
63242 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
63245 if( pPg->pgno>nPageCount ){
63246 nPage = (pPg->pgno - pg1)+1;
63253 assert(pg1<=pPg->pgno);
63254 assert((pg1+nPage)>pPg->pgno);
63259 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
63314 SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
63315 Pager *pPager = pPg->pPager;
63316 assert( (pPg->flags & PGHDR_MMAP)==0 );
63319 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
63320 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
63326 return pagerWriteLargeSector(pPg);
63328 return pager_write(pPg);
63338 SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){
63339 return pPg->flags & PGHDR_WRITEABLE;
63345 ** write the information on page pPg back to the disk, even though
63359 ** memory pressure forces page pPg out of the cache, the data does need
63363 SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
63364 Pager *pPager = pPg->pPager;
63365 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
63366 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
63367 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
63368 pPg->flags |= PGHDR_DONT_WRITE;
63369 pPg->flags &= ~PGHDR_WRITEABLE;
63370 testcase( pPg->flags & PGHDR_NEED_SYNC );
63371 pager_set_pagehash(pPg);
63638 PgHdr *pPg;
63646 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
64214 ** Move the page pPg to location pgno in the file.
64221 ** References to the page pPg remain valid. Updating any
64222 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
64233 ** pPg refers to will not be written to again within this transaction.
64238 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
64240 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
64244 assert( pPg->nRef>0 );
64255 rc = sqlite3PagerWrite(pPg);
64273 ** subjournalPage() may need to allocate space to store pPg->pgno into
64277 if( (pPg->flags & PGHDR_DIRTY)!=0
64278 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
64284 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
64285 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
64287 /* If the journal needs to be sync()ed before page pPg->pgno can
64288 ** be written to, store pPg->pgno in local variable needSyncPgno.
64291 ** the journal needs to be sync()ed before database page pPg->pgno
64294 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
64295 needSyncPgno = pPg->pgno;
64297 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
64298 assert( pPg->flags&PGHDR_DIRTY );
64306 pPg->flags &= ~PGHDR_NEED_SYNC;
64314 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
64324 origPgno = pPg->pgno;
64325 sqlite3PcacheMove(pPg, pgno);
64326 sqlite3PcacheMakeDirty(pPg);
64376 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
64377 assert( pPg->pgno!=iNew );
64378 pPg->flags = flags;
64379 sqlite3PcacheMove(pPg, iNew);
64385 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){
64386 assert( pPg->nRef>0 || pPg->pPager->memDb );
64387 return pPg->pData;
64394 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){
64395 return pPg->pExtra;
72272 ** Search the free-list on page pPg for space to store a cell nByte bytes in
72278 ** This function may detect corruption within pPg. If corruption is
72285 static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
72286 const int hdr = pPg->hdrOffset; /* Offset to page header */
72287 u8 * const aData = pPg->aData; /* Page data */
72292 int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */
72317 *pRc = SQLITE_CORRUPT_PAGE(pPg);
72332 *pRc = SQLITE_CORRUPT_PAGE(pPg);
72339 *pRc = SQLITE_CORRUPT_PAGE(pPg);
77231 MemPage *pPg = 0;
77234 rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent);
77236 rc = sqlite3PagerWrite(pPg->pDbPage);
77237 releasePage(pPg);
78078 ** replaces the current contents of page pPg with the contents of the cell
78081 ** Some of the cells in apCell[] may currently be stored in pPg. This
78089 CellArray *pCArray, /* Content to be added to page pPg */
78092 MemPage *pPg /* The page to be reconstructed */
78094 const int hdr = pPg->hdrOffset; /* Offset of header on pPg */
78095 u8 * const aData = pPg->aData; /* Pointer to data for pPg */
78096 const int usableSize = pPg->pBt->usableSize;
78101 u8 *pCellptr = pPg->aCellIdx;
78102 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
78135 assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
78144 /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
78145 pPg->nCell = nCell;
78146 pPg->nOverflow = 0;
78149 put2byte(&aData[hdr+3], pPg->nCell);
78157 ** This function attempts to add the cells stored in the array to page pPg.
78163 ** (part of page pPg) to populate. After cell apCell[0] is written to the
78169 ** content area on page pPg. If the size of the content area is extended,
78180 MemPage *pPg, /* Page to add cells to */
78185 int nCell, /* Number of cells to add to pPg */
78189 u8 *aData = pPg->aData; /* Complete page */
78194 assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */
78203 if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
78239 ** that is currently stored within the body of pPg to the pPg free-list.
78245 MemPage *pPg, /* Page to edit */
78250 u8 * const aData = pPg->aData;
78251 u8 * const pEnd = &aData[pPg->pBt->usableSize];
78252 u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
78284 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
78297 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
78304 ** balanced. The current page, pPg, has pPg->nCell cells starting with
78308 ** This routine makes the necessary adjustments to pPg so that it contains
78311 ** The pPg->nFree field is invalid when this function returns. It is the
78315 MemPage *pPg, /* Edit this page */
78321 u8 * const aData = pPg->aData;
78322 const int hdr = pPg->hdrOffset;
78323 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
78324 int nCell = pPg->nCell; /* Cells stored on pPg */
78328 int iOldEnd = iOld + pPg->nCell + pPg->nOverflow;
78332 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
78333 memcpy(pTmp, aData, pPg->pBt->usableSize);
78339 int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
78341 memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2);
78345 int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray);
78352 if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail;
78359 pCellptr = pPg->aCellIdx;
78362 pPg, pBegin, &pData, pCellptr,
78369 for(i=0; i<pPg->nOverflow; i++){
78370 int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
78372 pCellptr = &pPg->aCellIdx[iCell * 2];
78379 pPg, pBegin, &pData, pCellptr,
78387 pCellptr = &pPg->aCellIdx[nCell*2];
78389 pPg, pBegin, &pData, pCellptr,
78393 pPg->nCell = nNew;
78394 pPg->nOverflow = 0;
78396 put2byte(&aData[hdr+3], pPg->nCell);
78402 int iOff = get2byteAligned(&pPg->aCellIdx[i*2]);
78403 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
78416 return rebuildPage(pCArray, iNew, nNew, pPg);
82505 DbPage *pPg;
82506 rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0);
82508 rc = sqlite3PagerWrite(pPg);
82509 sqlite3PagerUnref(pPg);
224023 DbPage *pPg = 0;
224024 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
224026 assert( pPg==0 );
224029 pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
224030 sqlite3PagerUnref(pPg);
224073 ** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
224079 StatPage *pPg /* Load page into this object */
224085 if( pPg->aPg==0 ){
224086 pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES);
224087 if( pPg->aPg==0 ){
224090 memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES);
224096 memcpy(pPg->aPg, a, pgsz);
243758 #define TOMBSTONE_KEYSIZE(pPg) (pPg->p[0]==4 ? 4 : 8)
243760 #define TOMBSTONE_NSLOT(pPg) \
243761 ((pPg->nn > 16) ? ((pPg->nn-8) / TOMBSTONE_KEYSIZE(pPg)) : 1)
245900 Fts5Data *pPg = fts5DataRead(p, FTS5_SEGMENT_ROWID(iSegid, iPgno));
245901 int bEmpty = (pPg && pPg->nn==4);
245902 fts5DataRelease(pPg);
247899 ** Buffer pPg contains a page of a tombstone hash table - one of nPg pages
247910 Fts5Data *pPg,
247915 const int szKey = TOMBSTONE_KEYSIZE(pPg);
247916 const int nSlot = TOMBSTONE_NSLOT(pPg);
247917 const int nElem = fts5GetU32(&pPg->p[4]);
247923 pPg->p[1] = 0x01;
247931 fts5PutU32(&pPg->p[4], nElem+1);
247933 u32 *aSlot = (u32*)&pPg->p[8];
247940 u64 *aSlot = (u64*)&pPg->p[8];
248010 Fts5Data *pPg = apOut[(iVal % nOut)];
248011 res = fts5IndexTombstoneAddToPage(pPg, 0, nOut, iVal);
248146 Fts5Data *pPg = 0;
248156 pPg = fts5DataRead(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg));
248157 if( pPg==0 ){
248162 if( 0==fts5IndexTombstoneAddToPage(pPg, 0, pSeg->nPgTombstone, iRowid) ){
248163 fts5DataWrite(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg), pPg->p, pPg->nn);
248164 fts5DataRelease(pPg);
248170 szKey = pPg ? TOMBSTONE_KEYSIZE(pPg) : 4;
248174 fts5IndexTombstoneRebuild(p, pSeg, pPg, iPg, szKey, &nHash, &apHash);
248190 fts5DataRelease(pPg);