Lines Matching refs:pPg
56765 PgHdr *pPg;
56771 pPg = (PgHdr*)pLower->pExtra;
56772 printf("%3d: nRef %2lld flgs %02x data ", i, pPg->nRef, pPg->flags);
56775 printf(" ptr %p\n", pPg);
56802 ** Return 1 if pPg
56806 static int pageOnDirtyList(PCache *pCache, PgHdr *pPg){
56809 if( p==pPg ) return 1;
56813 static int pageNotOnDirtyList(PCache *pCache, PgHdr *pPg){
56816 if( p==pPg ) return 0;
56832 ** assert( sqlite3PcachePageSanity(pPg) );
56835 SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
56837 assert( pPg!=0 );
56838 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
56839 pCache = pPg->pCache;
56841 if( pPg->flags & PGHDR_CLEAN ){
56842 assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */
56843 assert( pageNotOnDirtyList(pCache, pPg) );/* CLEAN pages not on dirtylist */
56845 assert( (pPg->flags & PGHDR_DIRTY)!=0 );/* If not CLEAN must be DIRTY */
56846 assert( pPg->pDirtyNext==0 || pPg->pDirtyNext->pDirtyPrev==pPg );
56847 assert( pPg->pDirtyPrev==0 || pPg->pDirtyPrev->pDirtyNext==pPg );
56848 assert( pPg->pDirtyPrev!=0 || pCache->pDirty==pPg );
56849 assert( pageOnDirtyList(pCache, pPg) );
56852 if( pPg->flags & PGHDR_WRITEABLE ){
56853 assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */
57145 PgHdr *pPg;
57158 for(pPg=pCache->pSynced;
57159 pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
57160 pPg=pPg->pDirtyPrev
57162 pCache->pSynced = pPg;
57163 if( !pPg ){
57164 for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
57166 if( pPg ){
57171 pPg->pgno, pgno,
57175 pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
57176 rc = pCache->xStress(pCache->pStress, pPg);
58065 void *pPg;
58083 pPg = pcache1Alloc(pCache->szAlloc);
58088 if( pPg==0 ) return 0;
58089 p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
58090 p->page.pBuf = pPg;
58712 sqlite3_pcache_page *pPg,
58716 PgHdr1 *pPage = (PgHdr1 *)pPg;
58747 sqlite3_pcache_page *pPg,
58752 PgHdr1 *pPage = (PgHdr1 *)pPg;
58761 assert( pcache1FetchNoMutex(p, iOld, 0)==pPage ); /* pPg really is iOld */
60642 ** Return true if it is necessary to write page *pPg into the sub-journal.
60650 static int subjRequiresPage(PgHdr *pPg){
60651 Pager *pPager = pPg->pPager;
60653 Pgno pgno = pPg->pgno;
60671 static int pageInJournal(Pager *pPager, PgHdr *pPg){
60672 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
60845 static void checkPage(PgHdr *pPg){
60846 Pager *pPager = pPg->pPager;
60848 assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
61879 PgHdr *pPg; /* An existing page in the cache */
61985 pPg = 0;
61987 pPg = sqlite3PagerLookup(pPager, pgno);
61989 assert( pPg || !MEMDB );
61990 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
61998 isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
62005 testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
62022 }else if( !isMainJrnl && pPg==0 ){
62042 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
62046 sqlite3PcacheMakeDirty(pPg);
62048 if( pPg ){
62056 pData = pPg->pData;
62058 pPager->xReiniter(pPg);
62059 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
62063 pager_set_pagehash(pPg);
62070 sqlite3PcacheRelease(pPg);
62594 ** Read the content for page pPg out of the database file (or out of
62596 ** pPg->pData. A shared lock or greater must be held on the database
62605 static int readDbPage(PgHdr *pPg){
62606 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
62616 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
62620 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
62624 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
62625 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
62631 if( pPg->pgno==1 ){
62647 u8 *dbFileVers = &((u8*)pPg->pData)[24];
62653 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
62655 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
62668 static void pager_write_changecounter(PgHdr *pPg){
62670 if( NEVER(pPg==0) ) return;
62673 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
62674 put32bits(((char*)pPg->pData)+24, change_counter);
62679 put32bits(((char*)pPg->pData)+92, change_counter);
62680 put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
62699 PgHdr *pPg;
62702 pPg = sqlite3PagerLookup(pPager, iPg);
62703 if( pPg ){
62704 if( sqlite3PcachePageRefcount(pPg)==1 ){
62705 sqlite3PcacheDrop(pPg);
62707 rc = readDbPage(pPg);
62709 pPager->xReiniter(pPg);
62711 sqlite3PagerUnrefNotNull(pPg);
63571 static void assertTruncateConstraintCb(PgHdr *pPg){
63572 Pager *pPager = pPg->pPager;
63573 assert( pPg->flags&PGHDR_DIRTY );
63574 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
63575 Pgno pgno = pPg->pgno;
63577 for(i=0; i<pPg->pPager->nSavepoint; i++){
63696 ** Release a reference to page pPg. pPg must have been returned by an
63699 static void pagerReleaseMapPage(PgHdr *pPg){
63700 Pager *pPager = pPg->pPager;
63702 pPg->pDirty = pPager->pMmapFreelist;
63703 pPager->pMmapFreelist = pPg;
63706 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
63821 ** Return the page number for page pPg.
63823 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
63824 return pPg->pgno;
63829 ** Increment the reference count for page pPg.
63831 SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){
63832 sqlite3PcacheRef(pPg);
64120 ** Append a record of the current state of page pPg to the sub-journal.
64122 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
64130 static int subjournalPage(PgHdr *pPg){
64132 Pager *pPager = pPg->pPager;
64140 || pageInJournal(pPager, pPg)
64141 || pPg->pgno>pPager->dbOrigSize
64148 void *pData = pPg->pData;
64152 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
64153 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
64162 rc = addToSavepointBitvecs(pPager, pPg->pgno);
64166 static int subjournalPageIfRequired(PgHdr *pPg){
64167 if( subjRequiresPage(pPg) ){
64168 return subjournalPage(pPg);
64183 ** The job of this function is to make pPg clean by writing its contents
64193 static int pagerStress(void *p, PgHdr *pPg){
64197 assert( pPg->pPager==pPager );
64198 assert( pPg->flags&PGHDR_DIRTY );
64222 || (pPg->flags & PGHDR_NEED_SYNC)!=0)
64228 pPg->pDirty = 0;
64231 rc = subjournalPageIfRequired(pPg);
64233 rc = pagerWalFrames(pPager, pPg, 0, 0);
64245 if( pPg->flags&PGHDR_NEED_SYNC
64253 assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
64254 rc = pager_write_pagelist(pPager, pPg);
64260 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
64261 sqlite3PcacheMakeClean(pPg);
65126 PgHdr *pPg;
65138 pPg = 0;
65146 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
65147 assert( pPg==(*ppPage) );
65148 assert( pPg->pgno==pgno );
65149 assert( pPg->pPager==pPager || pPg->pPager==0 );
65152 if( pPg->pPager && !noContent ){
65171 pPg->pPager = pPager;
65178 sqlite3PcacheRelease(pPg);
65179 pPg = 0;
65199 memset(pPg->pData, 0, pPager->pageSize);
65202 assert( pPg->pPager==pPager );
65204 rc = readDbPage(pPg);
65209 pager_set_pagehash(pPg);
65215 if( pPg ){
65216 sqlite3PcacheDrop(pPg);
65232 PgHdr *pPg = 0;
65271 pPg = sqlite3PagerLookup(pPager, pgno);
65273 if( pPg==0 ){
65274 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
65278 if( pPg ){
65280 *ppPage = pPg;
65368 SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
65369 TESTONLY( Pager *pPager = pPg->pPager; )
65370 assert( pPg!=0 );
65371 if( pPg->flags & PGHDR_MMAP ){
65372 assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
65373 pagerReleaseMapPage(pPg);
65375 sqlite3PcacheRelease(pPg);
65380 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
65381 if( pPg ) sqlite3PagerUnrefNotNull(pPg);
65383 SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){
65385 assert( pPg!=0 );
65386 assert( pPg->pgno==1 );
65387 assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
65388 pPager = pPg->pPager;
65389 sqlite3PcacheRelease(pPg);
65573 ** Write page pPg onto the end of the rollback journal.
65575 static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
65576 Pager *pPager = pPg->pPager;
65585 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
65588 pData2 = pPg->pData;
65598 pPg->flags |= PGHDR_NEED_SYNC;
65600 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
65607 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
65611 PAGERID(pPager), pPg->pgno,
65612 ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
65617 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
65620 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
65632 static int pager_write(PgHdr *pPg){
65633 Pager *pPager = pPg->pPager;
65647 CHECK_PAGE(pPg);
65666 sqlite3PcacheMakeDirty(pPg);
65674 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
65677 if( pPg->pgno<=pPager->dbOrigSize ){
65678 rc = pagerAddPageToRollbackJournal(pPg);
65684 pPg->flags |= PGHDR_NEED_SYNC;
65687 PAGERID(pPager), pPg->pgno,
65688 ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
65697 pPg->flags |= PGHDR_WRITEABLE;
65703 rc = subjournalPageIfRequired(pPg);
65707 if( pPager->dbSize<pPg->pgno ){
65708 pPager->dbSize = pPg->pgno;
65724 static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
65727 Pgno pg1; /* First page of the sector pPg is located on. */
65731 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
65744 ** of the first page of the sector pPg is located on.
65746 pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
65749 if( pPg->pgno>nPageCount ){
65750 nPage = (pPg->pgno - pg1)+1;
65757 assert(pg1<=pPg->pgno);
65758 assert((pg1+nPage)>pPg->pgno);
65763 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
65818 SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
65819 Pager *pPager = pPg->pPager;
65820 assert( (pPg->flags & PGHDR_MMAP)==0 );
65823 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
65824 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
65830 return pagerWriteLargeSector(pPg);
65832 return pager_write(pPg);
65842 SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){
65843 return pPg->flags & PGHDR_WRITEABLE;
65849 ** write the information on page pPg back to the disk, even though
65863 ** memory pressure forces page pPg out of the cache, the data does need
65867 SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
65868 Pager *pPager = pPg->pPager;
65869 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
65870 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
65871 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
65872 pPg->flags |= PGHDR_DONT_WRITE;
65873 pPg->flags &= ~PGHDR_WRITEABLE;
65874 testcase( pPg->flags & PGHDR_NEED_SYNC );
65875 pager_set_pagehash(pPg);
66142 PgHdr *pPg;
66150 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
66718 ** Move the page pPg to location pgno in the file.
66725 ** References to the page pPg remain valid. Updating any
66726 ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
66737 ** pPg refers to will not be written to again within this transaction.
66742 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
66744 Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
66748 assert( pPg->nRef>0 );
66759 rc = sqlite3PagerWrite(pPg);
66777 ** subjournalPage() may need to allocate space to store pPg->pgno into
66781 if( (pPg->flags & PGHDR_DIRTY)!=0
66782 && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg))
66788 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
66789 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
66791 /* If the journal needs to be sync()ed before page pPg->pgno can
66792 ** be written to, store pPg->pgno in local variable needSyncPgno.
66795 ** the journal needs to be sync()ed before database page pPg->pgno
66798 if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
66799 needSyncPgno = pPg->pgno;
66801 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
66802 assert( pPg->flags&PGHDR_DIRTY );
66810 pPg->flags &= ~PGHDR_NEED_SYNC;
66818 pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
66828 origPgno = pPg->pgno;
66829 sqlite3PcacheMove(pPg, pgno);
66830 sqlite3PcacheMakeDirty(pPg);
66880 SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){
66881 assert( pPg->pgno!=iNew );
66882 pPg->flags = flags;
66883 sqlite3PcacheMove(pPg, iNew);
66889 SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){
66890 assert( pPg->nRef>0 || pPg->pPager->memDb );
66891 return pPg->pData;
66898 SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){
66899 return pPg->pExtra;
74853 ** Search the free-list on page pPg for space to store a cell nByte bytes in
74859 ** This function may detect corruption within pPg. If corruption is
74866 static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
74867 const int hdr = pPg->hdrOffset; /* Offset to page header */
74868 u8 * const aData = pPg->aData; /* Page data */
74873 int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */
74898 *pRc = SQLITE_CORRUPT_PAGE(pPg);
74913 *pRc = SQLITE_CORRUPT_PAGE(pPg);
74920 *pRc = SQLITE_CORRUPT_PAGE(pPg);
79891 MemPage *pPg = 0;
79894 rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent);
79896 rc = sqlite3PagerWrite(pPg->pDbPage);
79897 releasePage(pPg);
80738 ** replaces the current contents of page pPg with the contents of the cell
80741 ** Some of the cells in apCell[] may currently be stored in pPg. This
80749 CellArray *pCArray, /* Content to be added to page pPg */
80752 MemPage *pPg /* The page to be reconstructed */
80754 const int hdr = pPg->hdrOffset; /* Offset of header on pPg */
80755 u8 * const aData = pPg->aData; /* Pointer to data for pPg */
80756 const int usableSize = pPg->pBt->usableSize;
80761 u8 *pCellptr = pPg->aCellIdx;
80762 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
80796 assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
80805 /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
80807 pPg->nCell = (u16)nCell;
80808 pPg->nOverflow = 0;
80811 put2byte(&aData[hdr+3], pPg->nCell);
80819 ** This function attempts to add the cells stored in the array to page pPg.
80825 ** (part of page pPg) to populate. After cell apCell[0] is written to the
80831 ** content area on page pPg. If the size of the content area is extended,
80842 MemPage *pPg, /* Page to add cells to */
80847 int nCell, /* Number of cells to add to pPg */
80851 u8 *aData = pPg->aData; /* Complete page */
80856 assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */
80866 if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
80902 ** that is currently stored within the body of pPg to the pPg free-list.
80908 MemPage *pPg, /* Page to edit */
80913 u8 * const aData = pPg->aData;
80914 u8 * const pEnd = &aData[pPg->pBt->usableSize];
80915 u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
80947 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
80960 freeSpace(pPg, aOfst[j], aAfter[j]-aOfst[j]);
80967 ** balanced. The current page, pPg, has pPg->nCell cells starting with
80971 ** This routine makes the necessary adjustments to pPg so that it contains
80974 ** The pPg->nFree field is invalid when this function returns. It is the
80978 MemPage *pPg, /* Edit this page */
80984 u8 * const aData = pPg->aData;
80985 const int hdr = pPg->hdrOffset;
80986 u8 *pBegin = &pPg->aCellIdx[nNew * 2];
80987 int nCell = pPg->nCell; /* Cells stored on pPg */
80991 int iOldEnd = iOld + pPg->nCell + pPg->nOverflow;
80995 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
80996 memcpy(pTmp, aData, pPg->pBt->usableSize);
81002 int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
81004 memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2);
81008 int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray);
81015 if( NEVER(pData>pPg->aDataEnd) ) goto editpage_fail;
81022 pCellptr = pPg->aCellIdx;
81025 pPg, pBegin, &pData, pCellptr,
81032 for(i=0; i<pPg->nOverflow; i++){
81033 int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
81035 pCellptr = &pPg->aCellIdx[iCell * 2];
81042 pPg, pBegin, &pData, pCellptr,
81050 pCellptr = &pPg->aCellIdx[nCell*2];
81052 pPg, pBegin, &pData, pCellptr,
81060 pPg->nCell = (u16)nNew;
81061 pPg->nOverflow = 0;
81063 put2byte(&aData[hdr+3], pPg->nCell);
81069 int iOff = get2byteAligned(&pPg->aCellIdx[i*2]);
81070 if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){
81083 return rebuildPage(pCArray, iNew, nNew, pPg);
85183 DbPage *pPg;
85184 rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0);
85186 rc = sqlite3PagerWrite(pPg);
85187 sqlite3PagerUnref(pPg);
231849 DbPage *pPg = 0;
231850 rc = sqlite3PagerGet(sqlite3BtreePager(pBt), iPrev, &pPg, 0);
231852 assert( pPg==0 );
231855 pCell->aOvfl[j] = sqlite3Get4byte(sqlite3PagerGetData(pPg));
231856 sqlite3PagerUnref(pPg);
231899 ** to page object pPg. Allocate the buffer if necessary. Return SQLITE_OK
231905 StatPage *pPg /* Load page into this object */
231911 if( pPg->aPg==0 ){
231912 pPg->aPg = (u8*)sqlite3_malloc(pgsz + DBSTAT_PAGE_PADDING_BYTES);
231913 if( pPg->aPg==0 ){
231916 memset(&pPg->aPg[pgsz], 0, DBSTAT_PAGE_PADDING_BYTES);
231922 memcpy(pPg->aPg, a, pgsz);
253368 #define TOMBSTONE_KEYSIZE(pPg) (pPg->p[0]==4 ? 4 : 8)
253370 #define TOMBSTONE_NSLOT(pPg) \
253371 ((pPg->nn > 16) ? ((pPg->nn-8) / TOMBSTONE_KEYSIZE(pPg)) : 1)
255522 Fts5Data *pPg = fts5DataRead(p, FTS5_SEGMENT_ROWID(iSegid, iPgno));
255523 int bEmpty = (pPg && pPg->nn==4);
255524 fts5DataRelease(pPg);
257906 ** Buffer pPg contains a page of a tombstone hash table - one of nPg pages
257917 Fts5Data *pPg,
257922 const int szKey = TOMBSTONE_KEYSIZE(pPg);
257923 const int nSlot = TOMBSTONE_NSLOT(pPg);
257924 const int nElem = fts5GetU32(&pPg->p[4]);
257930 pPg->p[1] = 0x01;
257938 fts5PutU32(&pPg->p[4], nElem+1);
257940 u32 *aSlot = (u32*)&pPg->p[8];
257947 u64 *aSlot = (u64*)&pPg->p[8];
258017 Fts5Data *pPg = apOut[(iVal % nOut)];
258018 res = fts5IndexTombstoneAddToPage(pPg, 0, nOut, iVal);
258153 Fts5Data *pPg = 0;
258163 pPg = fts5DataRead(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg));
258164 if( pPg==0 ){
258169 if( 0==fts5IndexTombstoneAddToPage(pPg, 0, pSeg->nPgTombstone, iRowid) ){
258170 fts5DataWrite(p, FTS5_TOMBSTONE_ROWID(pSeg->iSegid,iPg), pPg->p, pPg->nn);
258171 fts5DataRelease(pPg);
258177 szKey = pPg ? TOMBSTONE_KEYSIZE(pPg) : 4;
258181 fts5IndexTombstoneRebuild(p, pSeg, pPg, iPg, szKey, &nHash, &apHash);
258197 fts5DataRelease(pPg);
Indexes created Thu Jun 11 00:25:07 UTC 2026