Lines Matching refs:pPager
15893 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3*);
15914 SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
15915 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
15934 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper);
15937 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
15938 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
15939 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
15942 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*);
15943 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
15944 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
15945 SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
15946 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);
15950 SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager);
15951 SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot);
15952 SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager);
15965 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno);
15969 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager);
17136 Pager *pPager; /* The pager this page is part of */ member
24087 Pager *pPager = sqlite3BtreePager(pBt); in sqlite3_db_status() local
24088 int nByte = sqlite3PagerMemUsed(pPager); in sqlite3_db_status()
24189 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); in sqlite3_db_status() local
24190 sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); in sqlite3_db_status()
53682 Pager *pPager = sqlite3BtreePager(pBt);
53687 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
54361 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
57870 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
57876 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
57887 # define MEMDB pPager->memDb
57923 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
57924 if( pPager->fd->pMethods==0 ) return 0;
57925 if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
57927 if( pPager->pWal ){
57929 (void)sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
57957 Pager *pPager = p;
57974 assert( p->tempFile==0 || pPager->changeCountDone );
58003 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
58009 assert( pPager->errCode==SQLITE_OK );
58010 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
58014 assert( pPager->errCode==SQLITE_OK );
58021 assert( pPager->errCode==SQLITE_OK );
58022 if( !pagerUseWal(pPager) ){
58025 assert( pPager->dbSize==pPager->dbOrigSize );
58026 assert( pPager->dbOrigSize==pPager->dbFileSize );
58027 assert( pPager->dbOrigSize==pPager->dbHintSize );
58028 assert( pPager->setSuper==0 );
58033 assert( pPager->errCode==SQLITE_OK );
58034 if( !pagerUseWal(pPager) ){
58046 assert( pPager->dbOrigSize==pPager->dbFileSize );
58047 assert( pPager->dbOrigSize==pPager->dbHintSize );
58052 assert( pPager->errCode==SQLITE_OK );
58053 assert( !pagerUseWal(pPager) );
58060 assert( pPager->dbOrigSize<=pPager->dbHintSize );
58065 assert( pPager->errCode==SQLITE_OK );
58066 assert( !pagerUseWal(pPager) );
58079 assert( pPager->errCode!=SQLITE_OK );
58080 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
58154 static void setGetterMethod(Pager *pPager){
58155 if( pPager->errCode ){
58156 pPager->xGet = getPageError;
58158 }else if( USEFETCH(pPager) ){
58159 pPager->xGet = getPageMMap;
58162 pPager->xGet = getPageNormal;
58176 Pager *pPager = pPg->pPager;
58180 for(i=0; i<pPager->nSavepoint; i++){
58181 p = &pPager->aSavepoint[i];
58183 for(i=i+1; i<pPager->nSavepoint; i++){
58184 pPager->aSavepoint[i].bTruncateOnRelease = 0;
58196 static int pageInJournal(Pager *pPager, PgHdr *pPg){
58197 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
58242 static int pagerUnlockDb(Pager *pPager, int eLock){
58245 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
58247 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
58248 if( isOpen(pPager->fd) ){
58249 assert( pPager->eLock>=eLock );
58250 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
58251 if( pPager->eLock!=UNKNOWN_LOCK ){
58252 pPager->eLock = (u8)eLock;
58254 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
58256 pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */
58270 static int pagerLockDb(Pager *pPager, int eLock){
58274 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
58275 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
58276 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
58277 pPager->eLock = (u8)eLock;
58278 IOTRACE(("LOCK %p %d\n", pPager, eLock))
58303 static int jrnlBufferSize(Pager *pPager){
58310 assert( isOpen(pPager->fd) );
58311 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
58313 UNUSED_PARAMETER(pPager);
58317 if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
58324 int nSector = pPager->sectorSize;
58325 int szPage = pPager->pageSize;
58334 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
58358 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
58371 Pager *pPager = pPg->pPager;
58372 assert( pPager->eState!=PAGER_ERROR );
58464 static i64 journalHdrOffset(Pager *pPager){
58466 i64 c = pPager->journalOff;
58468 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
58470 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
58472 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
58497 static int zeroJournalHdr(Pager *pPager, int doTruncate){
58499 assert( isOpen(pPager->jfd) );
58500 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
58501 if( pPager->journalOff ){
58502 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
58504 IOTRACE(("JZEROHDR %p\n", pPager))
58506 rc = sqlite3OsTruncate(pPager->jfd, 0);
58509 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
58511 if( rc==SQLITE_OK && !pPager->noSync ){
58512 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
58523 rc = sqlite3OsFileSize(pPager->jfd, &sz);
58525 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
58547 static int writeJournalHdr(Pager *pPager){
58549 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
58550 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
58554 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
58556 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
58557 nHeader = JOURNAL_HDR_SZ(pPager);
58564 for(ii=0; ii<pPager->nSavepoint; ii++){
58565 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
58566 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
58570 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
58592 assert( isOpen(pPager->fd) || pPager->noSync );
58593 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
58594 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
58605 if( pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
58606 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
58620 sqlite3OsFileSize(pPager->jfd, &sz);
58622 assert( pPager->journalOff==journalHdrOffset(pPager) );
58623 assert( sqlite3JournalIsInMemory(pPager->jfd) );
58626 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
58629 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
58631 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
58634 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
58661 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
58662 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
58663 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
58664 assert( pPager->journalHdr <= pPager->journalOff );
58665 pPager->journalOff += nHeader;
58689 Pager *pPager, /* Pager object */
58699 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
58705 pPager->journalOff = journalHdrOffset(pPager);
58706 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
58709 iHdrOff = pPager->journalOff;
58716 if( isHot || iHdrOff!=pPager->journalHdr ){
58717 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
58730 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
58731 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
58732 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
58737 if( pPager->journalOff==0 ){
58742 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
58743 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
58753 iPageSize = pPager->pageSize;
58777 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
58786 pPager->sectorSize = iSectorSize;
58789 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
58813 static int writeSuperJournal(Pager *pPager, const char *zSuper){
58820 assert( pPager->setSuper==0 );
58821 assert( !pagerUseWal(pPager) );
58824 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
58825 || !isOpen(pPager->jfd)
58829 pPager->setSuper = 1;
58830 assert( pPager->journalHdr <= pPager->journalOff );
58841 if( pPager->fullSync ){
58842 pPager->journalOff = journalHdrOffset(pPager);
58844 iHdrOff = pPager->journalOff;
58849 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_SJ_PGNO(pPager))))
58850 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
58851 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
58852 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
58853 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
58858 pPager->journalOff += (nSuper+20);
58870 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
58871 && jrnlSize>pPager->journalOff
58873 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
58881 static void pager_reset(Pager *pPager){
58882 pPager->iDataVersion++;
58883 sqlite3BackupRestart(pPager->pBackup);
58884 sqlite3PcacheClear(pPager->pPCache);
58890 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){
58891 return pPager->iDataVersion;
58899 static void releaseAllSavepoints(Pager *pPager){
58901 for(ii=0; ii<pPager->nSavepoint; ii++){
58902 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
58904 if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
58905 sqlite3OsClose(pPager->sjfd);
58907 sqlite3_free(pPager->aSavepoint);
58908 pPager->aSavepoint = 0;
58909 pPager->nSavepoint = 0;
58910 pPager->nSubRec = 0;
58918 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
58922 for(ii=0; ii<pPager->nSavepoint; ii++){
58923 PagerSavepoint *p = &pPager->aSavepoint[ii];
58950 static void pager_unlock(Pager *pPager){
58952 assert( pPager->eState==PAGER_READER
58953 || pPager->eState==PAGER_OPEN
58954 || pPager->eState==PAGER_ERROR
58957 sqlite3BitvecDestroy(pPager->pInJournal);
58958 pPager->pInJournal = 0;
58959 releaseAllSavepoints(pPager);
58961 if( pagerUseWal(pPager) ){
58962 assert( !isOpen(pPager->jfd) );
58963 sqlite3WalEndReadTransaction(pPager->pWal);
58964 pPager->eState = PAGER_OPEN;
58965 }else if( !pPager->exclusiveMode ){
58967 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
58981 || 1!=(pPager->journalMode & 5)
58983 sqlite3OsClose(pPager->jfd);
58991 rc = pagerUnlockDb(pPager, NO_LOCK);
58992 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
58993 pPager->eLock = UNKNOWN_LOCK;
59000 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
59001 pPager->eState = PAGER_OPEN;
59009 assert( pPager->errCode==SQLITE_OK || !MEMDB );
59010 if( pPager->errCode ){
59011 if( pPager->tempFile==0 ){
59012 pager_reset(pPager);
59013 pPager->changeCountDone = 0;
59014 pPager->eState = PAGER_OPEN;
59016 pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
59018 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
59019 pPager->errCode = SQLITE_OK;
59020 setGetterMethod(pPager);
59023 pPager->journalOff = 0;
59024 pPager->journalHdr = 0;
59025 pPager->setSuper = 0;
59047 static int pager_error(Pager *pPager, int rc){
59051 pPager->errCode==SQLITE_FULL ||
59052 pPager->errCode==SQLITE_OK ||
59053 (pPager->errCode & 0xff)==SQLITE_IOERR
59056 pPager->errCode = rc;
59057 pPager->eState = PAGER_ERROR;
59058 setGetterMethod(pPager);
59063 static int pager_truncate(Pager *pPager, Pgno nPage);
59081 static int pagerFlushOnCommit(Pager *pPager, int bCommit){
59082 if( pPager->tempFile==0 ) return 1;
59084 if( !isOpen(pPager->fd) ) return 0;
59085 return (sqlite3PCachePercentDirty(pPager->pPCache)>=25);
59141 static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){
59158 assert( assert_pager_state(pPager) );
59159 assert( pPager->eState!=PAGER_ERROR );
59160 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
59164 releaseAllSavepoints(pPager);
59165 assert( isOpen(pPager->jfd) || pPager->pInJournal==0
59166 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
59168 if( isOpen(pPager->jfd) ){
59169 assert( !pagerUseWal(pPager) );
59172 if( sqlite3JournalIsInMemory(pPager->jfd) ){
59174 sqlite3OsClose(pPager->jfd);
59175 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
59176 if( pPager->journalOff==0 ){
59179 rc = sqlite3OsTruncate(pPager->jfd, 0);
59180 if( rc==SQLITE_OK && pPager->fullSync ){
59186 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
59189 pPager->journalOff = 0;
59190 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
59191 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
59193 rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile);
59194 pPager->journalOff = 0;
59201 int bDelete = !pPager->tempFile;
59202 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
59203 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
59204 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
59205 || pPager->journalMode==PAGER_JOURNALMODE_WAL
59207 sqlite3OsClose(pPager->jfd);
59209 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
59215 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
59216 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
59217 PgHdr *p = sqlite3PagerLookup(pPager, 1);
59225 sqlite3BitvecDestroy(pPager->pInJournal);
59226 pPager->pInJournal = 0;
59227 pPager->nRec = 0;
59229 if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){
59230 sqlite3PcacheCleanAll(pPager->pPCache);
59232 sqlite3PcacheClearWritable(pPager->pPCache);
59234 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
59237 if( pagerUseWal(pPager) ){
59242 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
59244 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
59251 assert( pPager->eLock==EXCLUSIVE_LOCK );
59252 rc = pager_truncate(pPager, pPager->dbSize);
59256 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
59260 if( !pPager->exclusiveMode
59261 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
59263 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
59265 pPager->eState = PAGER_READER;
59266 pPager->setSuper = 0;
59272 static int pager_playback(Pager *pPager, int isHot);
59291 static void pagerUnlockAndRollback(Pager *pPager){
59292 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
59293 assert( assert_pager_state(pPager) );
59294 if( pPager->eState>=PAGER_WRITER_LOCKED ){
59296 sqlite3PagerRollback(pPager);
59298 }else if( !pPager->exclusiveMode ){
59299 assert( pPager->eState==PAGER_READER );
59300 pager_end_transaction(pPager, 0, 0);
59302 }else if( pPager->eState==PAGER_ERROR
59303 && pPager->journalMode==PAGER_JOURNALMODE_MEMORY
59304 && isOpen(pPager->jfd)
59309 int errCode = pPager->errCode;
59310 u8 eLock = pPager->eLock;
59311 pPager->eState = PAGER_OPEN;
59312 pPager->errCode = SQLITE_OK;
59313 pPager->eLock = EXCLUSIVE_LOCK;
59314 pager_playback(pPager, 1);
59315 pPager->errCode = errCode;
59316 pPager->eLock = eLock;
59318 pager_unlock(pPager);
59340 static u32 pager_cksum(Pager *pPager, const u8 *aData){
59341 u32 cksum = pPager->cksumInit; /* Checksum value to return */
59342 int i = pPager->pageSize-200; /* Loop counter */
59388 Pager *pPager, /* The pager being played back */
59407 aData = pPager->pTmpSpace;
59409 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
59417 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
59418 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
59420 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
59425 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
59428 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
59430 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
59437 if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){
59441 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
59447 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
59461 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
59462 pPager->nReserve = ((u8*)aData)[20];
59500 if( pagerUseWal(pPager) ){
59503 pPg = sqlite3PagerLookup(pPager, pgno);
59506 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
59508 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
59512 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
59516 if( isOpen(pPager->fd)
59517 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
59520 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
59522 assert( !pagerUseWal(pPager) );
59530 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
59532 if( pgno>pPager->dbFileSize ){
59533 pPager->dbFileSize = pgno;
59535 if( pPager->pBackup ){
59536 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
59556 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
59557 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
59558 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
59559 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
59560 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
59573 memcpy(pData, (u8*)aData, pPager->pageSize);
59574 pPager->xReiniter(pPg);
59584 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
59634 static int pager_delsuper(Pager *pPager, const char *zSuper){
59635 sqlite3_vfs *pVfs = pPager->pVfs;
59752 static int pager_truncate(Pager *pPager, Pgno nPage){
59754 assert( pPager->eState!=PAGER_ERROR );
59755 assert( pPager->eState!=PAGER_READER );
59756 PAGERTRACE(("Truncate %d npage %u\n", PAGERID(pPager), nPage));
59759 if( isOpen(pPager->fd)
59760 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
59763 int szPage = pPager->pageSize;
59764 assert( pPager->eLock==EXCLUSIVE_LOCK );
59766 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
59770 rc = sqlite3OsTruncate(pPager->fd, newSize);
59772 char *pTmp = pPager->pTmpSpace;
59776 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &newSize);
59777 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
59780 pPager->dbFileSize = nPage;
59825 static void setSectorSize(Pager *pPager){
59826 assert( isOpen(pPager->fd) || pPager->tempFile );
59828 if( pPager->tempFile
59829 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
59835 pPager->sectorSize = 512;
59837 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
59898 static int pager_playback(Pager *pPager, int isHot){
59899 sqlite3_vfs *pVfs = pPager->pVfs;
59909 u32 savedPageSize = pPager->pageSize;
59914 assert( isOpen(pPager->jfd) );
59915 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
59931 zSuper = pPager->pTmpSpace;
59932 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
59940 pPager->journalOff = 0;
59953 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
59967 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
59968 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
59986 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
59987 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
59993 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
59994 rc = pager_truncate(pPager, mxPg);
59998 pPager->dbSize = mxPg;
59999 if( pPager->mxPgno<mxPg ){
60000 pPager->mxPgno = mxPg;
60009 pager_reset(pPager);
60012 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
60017 pPager->journalOff = szJ;
60043 rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1);
60051 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
60063 pPager->changeCountDone = pPager->tempFile;
60070 zSuper = &pPager->pTmpSpace[4];
60071 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
60075 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
60077 rc = sqlite3PagerSync(pPager, 0);
60080 rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0);
60087 assert( zSuper==&pPager->pTmpSpace[4] );
60088 memset(pPager->pTmpSpace, 0, 4);
60089 rc = pager_delsuper(pPager, zSuper);
60094 nPlayback, pPager->zJournal);
60101 setSectorSize(pPager);
60119 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
60125 assert( pPager->eState>=PAGER_READER && !MEMDB );
60126 assert( isOpen(pPager->fd) );
60128 if( pagerUseWal(pPager) ){
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);
60158 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
60161 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
60165 PAGER_INCR(pPager->nRead);
60166 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
60168 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
60186 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
60211 Pager *pPager = (Pager *)pCtx;
60214 assert( pagerUseWal(pPager) );
60215 pPg = sqlite3PagerLookup(pPager, iPg);
60222 pPager->xReiniter(pPg);
60236 sqlite3BackupRestart(pPager->pBackup);
60244 static int pagerRollbackWal(Pager *pPager){
60255 pPager->dbSize = pPager->dbOrigSize;
60256 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
60257 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60260 rc = pagerUndoCallback((void *)pPager, pList->pgno);
60277 Pager *pPager, /* Pager object */
60286 assert( pPager->pWal );
60313 pPager->aStat[PAGER_STAT_WRITE] += nList;
60316 rc = sqlite3WalFrames(pPager->pWal,
60317 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
60319 if( rc==SQLITE_OK && pPager->pBackup ){
60321 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
60326 pList = sqlite3PcacheDirtyList(pPager->pPCache);
60343 static int pagerBeginReadTransaction(Pager *pPager){
60347 assert( pagerUseWal(pPager) );
60348 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
60355 sqlite3WalEndReadTransaction(pPager->pWal);
60357 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
60359 pager_reset(pPager);
60360 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
60376 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
60385 assert( pPager->eState==PAGER_OPEN );
60386 assert( pPager->eLock>=SHARED_LOCK );
60387 assert( isOpen(pPager->fd) );
60388 assert( pPager->tempFile==0 );
60389 nPage = sqlite3WalDbsize(pPager->pWal);
60396 if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
60398 int rc = sqlite3OsFileSize(pPager->fd, &n);
60402 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
60409 if( nPage>pPager->mxPgno ){
60410 pPager->mxPgno = (Pgno)nPage;
60436 static int pagerOpenWalIfPresent(Pager *pPager){
60438 assert( pPager->eState==PAGER_OPEN );
60439 assert( pPager->eLock>=SHARED_LOCK );
60441 if( !pPager->tempFile ){
60444 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
60450 rc = pagerPagecount(pPager, &nPage);
60453 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
60455 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
60456 rc = sqlite3PagerOpenWal(pPager, 0);
60458 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
60459 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
60503 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
60509 assert( pPager->eState!=PAGER_ERROR );
60510 assert( pPager->eState>=PAGER_WRITER_LOCKED );
60523 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
60524 pPager->changeCountDone = pPager->tempFile;
60526 if( !pSavepoint && pagerUseWal(pPager) ){
60527 return pagerRollbackWal(pPager);
60535 szJ = pPager->journalOff;
60536 assert( pagerUseWal(pPager)==0 || szJ==0 );
60545 if( pSavepoint && !pagerUseWal(pPager) ){
60547 pPager->journalOff = pSavepoint->iOffset;
60548 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
60549 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
60553 pPager->journalOff = 0;
60561 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
60565 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
60574 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
60576 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
60578 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
60579 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
60583 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
60591 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
60593 if( pagerUseWal(pPager) ){
60594 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
60596 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
60597 assert( offset==(i64)ii*(4+pPager->pageSize) );
60598 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
60605 pPager->journalOff = szJ;
60615 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
60616 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
60623 SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){
60624 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
60630 static void pagerFixMaplimit(Pager *pPager){
60632 sqlite3_file *fd = pPager->fd;
60635 sz = pPager->szMmap;
60636 pPager->bUseFetch = (sz>0);
60637 setGetterMethod(pPager);
60638 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
60646 SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
60647 pPager->szMmap = szMmap;
60648 pagerFixMaplimit(pPager);
60654 SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){
60655 sqlite3PcacheShrink(pPager->pPCache);
60710 Pager *pPager, /* The pager to set safety level for */
60714 if( pPager->tempFile ){
60715 pPager->noSync = 1;
60716 pPager->fullSync = 0;
60717 pPager->extraSync = 0;
60719 pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0;
60720 pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
60721 pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
60723 if( pPager->noSync ){
60724 pPager->syncFlags = 0;
60726 pPager->syncFlags = SQLITE_SYNC_FULL;
60728 pPager->syncFlags = SQLITE_SYNC_NORMAL;
60730 pPager->walSyncFlags = (pPager->syncFlags<<2);
60731 if( pPager->fullSync ){
60732 pPager->walSyncFlags |= pPager->syncFlags;
60734 if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){
60735 pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2);
60738 pPager->doNotSpill &= ~SPILLFLAG_OFF;
60740 pPager->doNotSpill |= SPILLFLAG_OFF;
60769 Pager *pPager, /* The pager object */
60781 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
60808 Pager *pPager, /* Pager object */
60813 pPager->xBusyHandler = xBusyHandler;
60814 pPager->pBusyHandlerArg = pBusyHandlerArg;
60815 ap = (void **)&pPager->xBusyHandler;
60818 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
60851 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
60866 if( (pPager->memDb==0 || pPager->dbSize==0)
60867 && sqlite3PcacheRefCount(pPager->pPCache)==0
60868 && pageSize && pageSize!=(u32)pPager->pageSize
60873 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
60874 rc = sqlite3OsFileSize(pPager->fd, &nByte);
60888 pager_reset(pPager);
60889 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
60892 sqlite3PageFree(pPager->pTmpSpace);
60893 pPager->pTmpSpace = pNew;
60894 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
60895 pPager->pageSize = pageSize;
60896 pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1;
60902 *pPageSize = pPager->pageSize;
60904 if( nReserve<0 ) nReserve = pPager->nReserve;
60906 pPager->nReserve = (i16)nReserve;
60907 pagerFixMaplimit(pPager);
60920 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
60921 return pPager->pTmpSpace;
60931 SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){
60933 pPager->mxPgno = mxPage;
60935 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
60940 return pPager->mxPgno;
60981 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
60984 assert( isOpen(pPager->fd) || pPager->tempFile );
60990 assert( !pagerUseWal(pPager) );
60992 if( isOpen(pPager->fd) ){
60993 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
60994 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
61009 SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
61010 assert( pPager->eState>=PAGER_READER );
61011 assert( pPager->eState!=PAGER_WRITER_FINISHED );
61012 *pnPage = (int)pPager->dbSize;
61030 static int pager_wait_on_lock(Pager *pPager, int locktype){
61038 assert( (pPager->eLock>=locktype)
61039 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
61040 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
61044 rc = pagerLockDb(pPager, locktype);
61045 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
61072 Pager *pPager = pPg->pPager;
61074 if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */
61077 for(i=0; i<pPg->pPager->nSavepoint; i++){
61078 PagerSavepoint *p = &pPager->aSavepoint[i];
61083 static void assertTruncateConstraint(Pager *pPager){
61084 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
61087 # define assertTruncateConstraint(pPager)
61101 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
61102 assert( pPager->dbSize>=nPage || CORRUPT_DB );
61103 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
61104 pPager->dbSize = nPage;
61132 static int pagerSyncHotJournal(Pager *pPager){
61134 if( !pPager->noSync ){
61135 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
61138 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
61155 Pager *pPager, /* Pager object */
61162 if( pPager->pMmapFreelist ){
61163 *ppPage = p = pPager->pMmapFreelist;
61164 pPager->pMmapFreelist = p->pDirty;
61166 assert( pPager->nExtra>=8 );
61169 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
61171 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
61177 p->pPager = pPager;
61183 assert( p->pPager==pPager );
61188 pPager->nMmapOut++;
61199 Pager *pPager = pPg->pPager;
61200 pPager->nMmapOut--;
61201 pPg->pDirty = pPager->pMmapFreelist;
61202 pPager->pMmapFreelist = pPg;
61204 assert( pPager->fd->pMethods->iVersion>=3 );
61205 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
61211 static void pagerFreeMapHdrs(Pager *pPager){
61214 for(p=pPager->pMmapFreelist; p; p=pNext){
61225 static int databaseIsUnmoved(Pager *pPager){
61229 if( pPager->tempFile ) return SQLITE_OK;
61230 if( pPager->dbSize==0 ) return SQLITE_OK;
61231 assert( pPager->zFilename && pPager->zFilename[0] );
61232 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
61259 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){
61260 u8 *pTmp = (u8*)pPager->pTmpSpace;
61261 assert( db || pagerUseWal(pPager)==0 );
61262 assert( assert_pager_state(pPager) );
61265 pagerFreeMapHdrs(pPager);
61267 pPager->exclusiveMode = 0;
61271 assert( db || pPager->pWal==0 );
61273 && SQLITE_OK==databaseIsUnmoved(pPager)
61277 sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
61278 pPager->pWal = 0;
61281 pager_reset(pPager);
61283 pager_unlock(pPager);
61296 if( isOpen(pPager->jfd) ){
61297 pager_error(pPager, pagerSyncHotJournal(pPager));
61299 pagerUnlockAndRollback(pPager);
61303 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
61304 IOTRACE(("CLOSE %p\n", pPager))
61305 sqlite3OsClose(pPager->jfd);
61306 sqlite3OsClose(pPager->fd);
61308 sqlite3PcacheClose(pPager->pPCache);
61309 assert( !pPager->aSavepoint && !pPager->pInJournal );
61310 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
61312 sqlite3_free(pPager);
61367 static int syncJournal(Pager *pPager, int newHdr){
61370 assert( pPager->eState==PAGER_WRITER_CACHEMOD
61371 || pPager->eState==PAGER_WRITER_DBMOD
61373 assert( assert_pager_state(pPager) );
61374 assert( !pagerUseWal(pPager) );
61376 rc = sqlite3PagerExclusiveLock(pPager);
61379 if( !pPager->noSync ){
61380 assert( !pPager->tempFile );
61381 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
61382 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
61383 assert( isOpen(pPager->jfd) );
61413 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
61415 iNextHdrOffset = journalHdrOffset(pPager);
61416 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
61419 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
61436 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
61437 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
61438 IOTRACE(("JSYNC %p\n", pPager))
61439 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
61442 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
61444 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
61449 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
61450 IOTRACE(("JSYNC %p\n", pPager))
61451 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
61452 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
61457 pPager->journalHdr = pPager->journalOff;
61459 pPager->nRec = 0;
61460 rc = writeJournalHdr(pPager);
61464 pPager->journalHdr = pPager->journalOff;
61472 sqlite3PcacheClearSyncFlags(pPager->pPCache);
61473 pPager->eState = PAGER_WRITER_DBMOD;
61474 assert( assert_pager_state(pPager) );
61510 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
61514 assert( !pagerUseWal(pPager) );
61515 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
61516 assert( pPager->eLock==EXCLUSIVE_LOCK );
61517 assert( isOpen(pPager->fd) || pList->pDirty==0 );
61523 if( !isOpen(pPager->fd) ){
61524 assert( pPager->tempFile && rc==SQLITE_OK );
61525 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
61531 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
61533 && pPager->dbHintSize<pPager->dbSize
61534 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
61536 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
61537 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
61538 pPager->dbHintSize = pPager->dbSize;
61552 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
61553 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
61562 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
61569 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
61571 if( pgno>pPager->dbFileSize ){
61572 pPager->dbFileSize = pgno;
61574 pPager->aStat[PAGER_STAT_WRITE]++;
61577 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
61580 PAGERID(pPager), pgno, pager_pagehash(pList)));
61581 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
61584 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
61601 static int openSubJournal(Pager *pPager){
61603 if( !isOpen(pPager->sjfd) ){
61608 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
61611 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
61629 Pager *pPager = pPg->pPager;
61630 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
61633 assert( pPager->useJournal );
61634 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
61635 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
61636 assert( pagerUseWal(pPager)
61637 || pageInJournal(pPager, pPg)
61638 || pPg->pgno>pPager->dbOrigSize
61640 rc = openSubJournal(pPager);
61646 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
61649 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
61650 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
61652 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
61657 pPager->nSubRec++;
61658 assert( pPager->nSavepoint>0 );
61659 rc = addToSavepointBitvecs(pPager, pPg->pgno);
61691 Pager *pPager = (Pager *)p;
61694 assert( pPg->pPager==pPager );
61713 if( NEVER(pPager->errCode) ) return SQLITE_OK;
61714 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
61715 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
61716 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
61717 if( pPager->doNotSpill
61718 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
61724 pPager->aStat[PAGER_STAT_SPILL]++;
61726 if( pagerUseWal(pPager) ){
61730 rc = pagerWalFrames(pPager, pPg, 0, 0);
61735 if( pPager->tempFile==0 ){
61736 rc = sqlite3JournalCreate(pPager->jfd);
61737 if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
61743 || pPager->eState==PAGER_WRITER_CACHEMOD
61745 rc = syncJournal(pPager, 1);
61751 rc = pager_write_pagelist(pPager, pPg);
61757 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
61761 return pager_error(pPager, rc);
61767 SQLITE_PRIVATE int sqlite3PagerFlush(Pager *pPager){
61768 int rc = pPager->errCode;
61770 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
61771 assert( assert_pager_state(pPager) );
61775 rc = pagerStress((void*)pPager, pList);
61826 Pager *pPager = 0; /* Pager object to allocate and return */
61951 ROUND8(sizeof(*pPager)) + /* Pager structure */
61970 pPager = (Pager*)pPtr; pPtr += ROUND8(sizeof(*pPager));
61971 pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize);
61972 pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile);
61973 pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
61974 pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
61975 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
61976 memcpy(pPtr, &pPager, SQLITE_PTRSIZE); pPtr += SQLITE_PTRSIZE;
61980 pPager->zFilename = (char*)pPtr;
61993 pPager->zJournal = (char*)pPtr;
61997 sqlite3FileSuffix3(zFilename,pPager->zJournal);
61998 pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1);
62001 pPager->zJournal = 0;
62007 pPager->zWal = (char*)pPtr;
62011 sqlite3FileSuffix3(zFilename, pPager->zWal);
62012 pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
62015 pPager->zWal = 0;
62021 pPager->pVfs = pVfs;
62022 pPager->vfsFlags = vfsFlags;
62028 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
62030 pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
62042 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
62044 setSectorSize(pPager);
62046 if( szPageDflt<pPager->sectorSize ){
62047 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
62050 szPageDflt = (u32)pPager->sectorSize;
62067 pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
62069 || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
62087 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
62088 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
62089 pPager->noLock = 1; /* Do no locking */
62097 assert( pPager->memDb==0 );
62098 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
62107 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
62113 sqlite3OsClose(pPager->fd);
62114 sqlite3PageFree(pPager->pTmpSpace);
62115 sqlite3_free(pPager);
62119 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
62120 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
62122 pPager->useJournal = (u8)useJournal;
62129 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
62132 pPager->tempFile = (u8)tempFile;
62136 pPager->exclusiveMode = (u8)tempFile;
62137 pPager->changeCountDone = pPager->tempFile;
62138 pPager->memDb = (u8)memDb;
62139 pPager->readOnly = (u8)readOnly;
62140 assert( useJournal || pPager->tempFile );
62141 sqlite3PagerSetFlags(pPager, (SQLITE_DEFAULT_SYNCHRONOUS+1)|PAGER_CACHESPILL);
62145 pPager->nExtra = (u16)nExtra;
62146 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
62147 assert( isOpen(pPager->fd) || tempFile );
62148 setSectorSize(pPager);
62150 pPager->journalMode = PAGER_JOURNALMODE_OFF;
62152 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
62156 pPager->xReiniter = xReinit;
62157 setGetterMethod(pPager);
62161 *ppPager = pPager;
62171 Pager *pPager;
62178 pPager = *(Pager**)p;
62179 return pPager->fd;
62214 static int hasHotJournal(Pager *pPager, int *pExists){
62215 sqlite3_vfs * const pVfs = pPager->pVfs;
62218 int jrnlOpen = !!isOpen(pPager->jfd);
62220 assert( pPager->useJournal );
62221 assert( isOpen(pPager->fd) );
62222 assert( pPager->eState==PAGER_OPEN );
62224 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
62230 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
62243 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
62247 assert( pPager->tempFile==0 );
62248 rc = pagerPagecount(pPager, &nPage);
62260 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
62261 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
62262 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
62274 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
62278 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
62283 sqlite3OsClose(pPager->jfd);
62334 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
62341 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
62342 assert( assert_pager_state(pPager) );
62343 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
62344 assert( pPager->errCode==SQLITE_OK );
62346 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
62350 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
62352 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
62354 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
62361 if( pPager->eLock<=SHARED_LOCK ){
62362 rc = hasHotJournal(pPager, &bHotJournal);
62368 if( pPager->readOnly ){
62388 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
62406 if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
62407 sqlite3_vfs * const pVfs = pPager->pVfs;
62410 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
62414 assert( !pPager->tempFile );
62415 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
62416 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62419 sqlite3OsClose(pPager->jfd);
62432 if( isOpen(pPager->jfd) ){
62434 rc = pagerSyncHotJournal(pPager);
62436 rc = pager_playback(pPager, !pPager->tempFile);
62437 pPager->eState = PAGER_OPEN;
62439 }else if( !pPager->exclusiveMode ){
62440 pagerUnlockDb(pPager, SHARED_LOCK);
62460 pager_error(pPager, rc);
62464 assert( pPager->eState==PAGER_OPEN );
62465 assert( (pPager->eLock==SHARED_LOCK)
62466 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
62470 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
62487 char dbFileVers[sizeof(pPager->dbFileVers)];
62489 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
62490 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
62498 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
62499 pager_reset(pPager);
62507 if( USEFETCH(pPager) ){
62508 sqlite3OsUnfetch(pPager->fd, 0, 0);
62516 rc = pagerOpenWalIfPresent(pPager);
62518 assert( pPager->pWal==0 || rc==SQLITE_OK );
62522 if( pagerUseWal(pPager) ){
62524 rc = pagerBeginReadTransaction(pPager);
62527 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
62528 rc = pagerPagecount(pPager, &pPager->dbSize);
62534 pager_unlock(pPager);
62535 assert( pPager->eState==PAGER_OPEN );
62537 pPager->eState = PAGER_READER;
62538 pPager->hasHeldSharedLock = 1;
62551 static void pagerUnlockIfUnused(Pager *pPager){
62552 if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){
62553 assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
62554 pagerUnlockAndRollback(pPager);
62616 Pager *pPager, /* The pager open on the database file */
62626 assert( pPager->errCode==SQLITE_OK );
62627 assert( pPager->eState>=PAGER_READER );
62628 assert( assert_pager_state(pPager) );
62629 assert( pPager->hasHeldSharedLock==1 );
62632 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
62635 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
62642 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
62645 assert( pPg->pPager==pPager || pPg->pPager==0 );
62648 if( pPg->pPager && !noContent ){
62651 assert( pgno!=PAGER_SJ_PGNO(pPager) );
62652 pPager->aStat[PAGER_STAT_HIT]++;
62662 if( pgno==PAGER_SJ_PGNO(pPager) ){
62667 pPg->pPager = pPager;
62669 assert( !isOpen(pPager->fd) || !MEMDB );
62670 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
62671 if( pgno>pPager->mxPgno ){
62673 if( pgno<=pPager->dbSize ){
62687 if( pgno<=pPager->dbOrigSize ){
62688 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
62691 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
62695 memset(pPg->pData, 0, pPager->pageSize);
62696 IOTRACE(("ZERO %p %d\n", pPager, pgno));
62698 assert( pPg->pPager==pPager );
62699 pPager->aStat[PAGER_STAT_MISS]++;
62714 pagerUnlockIfUnused(pPager);
62722 Pager *pPager, /* The pager open on the database file */
62736 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
62739 assert( USEFETCH(pPager) );
62748 assert( pPager->eState>=PAGER_READER );
62749 assert( assert_pager_state(pPager) );
62750 assert( pPager->hasHeldSharedLock==1 );
62751 assert( pPager->errCode==SQLITE_OK );
62753 if( bMmapOk && pagerUseWal(pPager) ){
62754 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
62762 rc = sqlite3OsFetch(pPager->fd,
62763 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
62766 if( pPager->eState>PAGER_READER || pPager->tempFile ){
62767 pPg = sqlite3PagerLookup(pPager, pgno);
62770 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
62772 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
62785 return getPageNormal(pPager, pgno, ppPage, flags);
62791 Pager *pPager, /* The pager open on the database file */
62798 assert( pPager->errCode!=SQLITE_OK );
62800 return pPager->errCode;
62807 Pager *pPager, /* The pager open on the database file */
62816 rc = pPager->xGet(pPager, pgno, ppPage, flags);
62824 return pPager->xGet(pPager, pgno, ppPage, flags);
62839 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
62841 assert( pPager!=0 );
62843 assert( pPager->pPCache!=0 );
62844 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
62845 assert( pPage==0 || pPager->hasHeldSharedLock );
62847 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
62865 TESTONLY( Pager *pPager = pPg->pPager; )
62874 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 ); /* tag-20230419-2 */
62880 Pager *pPager;
62884 pPager = pPg->pPager;
62886 pagerUnlockIfUnused(pPager);
62911 static int pager_open_journal(Pager *pPager){
62913 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
62915 assert( pPager->eState==PAGER_WRITER_LOCKED );
62916 assert( assert_pager_state(pPager) );
62917 assert( pPager->pInJournal==0 );
62922 if( NEVER(pPager->errCode) ) return pPager->errCode;
62924 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
62925 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
62926 if( pPager->pInJournal==0 ){
62931 if( !isOpen(pPager->jfd) ){
62932 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
62933 sqlite3MemJournalOpen(pPager->jfd);
62938 if( pPager->tempFile ){
62944 nSpill = jrnlBufferSize(pPager);
62949 rc = databaseIsUnmoved(pPager);
62952 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
62956 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
62965 pPager->nRec = 0;
62966 pPager->journalOff = 0;
62967 pPager->setSuper = 0;
62968 pPager->journalHdr = 0;
62969 rc = writeJournalHdr(pPager);
62974 sqlite3BitvecDestroy(pPager->pInJournal);
62975 pPager->pInJournal = 0;
62976 pPager->journalOff = 0;
62978 assert( pPager->eState==PAGER_WRITER_LOCKED );
62979 pPager->eState = PAGER_WRITER_CACHEMOD;
63002 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
63005 if( pPager->errCode ) return pPager->errCode;
63006 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
63007 pPager->subjInMemory = (u8)subjInMemory;
63009 if( pPager->eState==PAGER_READER ){
63010 assert( pPager->pInJournal==0 );
63012 if( pagerUseWal(pPager) ){
63016 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
63017 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
63021 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
63029 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
63036 rc = pagerLockDb(pPager, RESERVED_LOCK);
63038 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
63052 pPager->eState = PAGER_WRITER_LOCKED;
63053 pPager->dbHintSize = pPager->dbSize;
63054 pPager->dbFileSize = pPager->dbSize;
63055 pPager->dbOrigSize = pPager->dbSize;
63056 pPager->journalOff = 0;
63059 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
63060 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
63061 assert( assert_pager_state(pPager) );
63064 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
63072 Pager *pPager = pPg->pPager;
63076 i64 iOff = pPager->journalOff;
63081 assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
63083 assert( pPager->journalHdr<=pPager->journalOff );
63085 cksum = pager_cksum(pPager, (u8*)pData2);
63096 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
63098 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
63100 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
63103 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
63104 pPager->journalOff, pPager->pageSize));
63107 PAGERID(pPager), pPg->pgno,
63110 pPager->journalOff += 8 + pPager->pageSize;
63111 pPager->nRec++;
63112 assert( pPager->pInJournal!=0 );
63113 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
63116 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
63129 Pager *pPager = pPg->pPager;
63136 assert( pPager->eState==PAGER_WRITER_LOCKED
63137 || pPager->eState==PAGER_WRITER_CACHEMOD
63138 || pPager->eState==PAGER_WRITER_DBMOD
63140 assert( assert_pager_state(pPager) );
63141 assert( pPager->errCode==0 );
63142 assert( pPager->readOnly==0 );
63154 if( pPager->eState==PAGER_WRITER_LOCKED ){
63155 rc = pager_open_journal(pPager);
63158 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
63159 assert( assert_pager_state(pPager) );
63168 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
63169 if( pPager->pInJournal!=0
63170 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
63172 assert( pagerUseWal(pPager)==0 );
63173 if( pPg->pgno<=pPager->dbOrigSize ){
63179 if( pPager->eState!=PAGER_WRITER_DBMOD ){
63183 PAGERID(pPager), pPg->pgno,
63198 if( pPager->nSavepoint>0 ){
63203 if( pPager->dbSize<pPg->pgno ){
63204 pPager->dbSize = pPg->pgno;
63227 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
63228 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
63235 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
63236 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
63244 nPageCount = pPager->dbSize;
63259 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
63260 if( pg!=PAGER_SJ_PGNO(pPager) ){
63261 rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
63270 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
63287 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
63295 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
63296 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
63315 Pager *pPager = pPg->pPager;
63317 assert( pPager->eState>=PAGER_WRITER_LOCKED );
63318 assert( assert_pager_state(pPager) );
63319 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
63320 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
63322 }else if( pPager->errCode ){
63323 return pPager->errCode;
63324 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
63325 assert( pPager->tempFile==0 );
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))
63397 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
63400 assert( pPager->eState==PAGER_WRITER_CACHEMOD
63401 || pPager->eState==PAGER_WRITER_DBMOD
63403 assert( assert_pager_state(pPager) );
63423 if( !pPager->changeCountDone && pPager->dbSize>0 ){
63426 assert( !pPager->tempFile && isOpen(pPager->fd) );
63429 rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
63448 assert( pPager->dbFileSize>0 );
63451 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
63452 pPager->aStat[PAGER_STAT_WRITE]++;
63459 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
63460 pPager->changeCountDone = 1;
63463 pPager->changeCountDone = 1;
63480 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){
63483 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
63485 if( rc==SQLITE_OK && !pPager->noSync ){
63487 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
63503 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
63504 int rc = pPager->errCode;
63505 assert( assert_pager_state(pPager) );
63507 assert( pPager->eState==PAGER_WRITER_CACHEMOD
63508 || pPager->eState==PAGER_WRITER_DBMOD
63509 || pPager->eState==PAGER_WRITER_LOCKED
63511 assert( assert_pager_state(pPager) );
63512 if( 0==pagerUseWal(pPager) ){
63513 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
63546 Pager *pPager, /* Pager object */
63552 assert( pPager->eState==PAGER_WRITER_LOCKED
63553 || pPager->eState==PAGER_WRITER_CACHEMOD
63554 || pPager->eState==PAGER_WRITER_DBMOD
63555 || pPager->eState==PAGER_ERROR
63557 assert( assert_pager_state(pPager) );
63560 if( NEVER(pPager->errCode) ) return pPager->errCode;
63566 pPager->zFilename, zSuper, pPager->dbSize));
63569 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
63571 assert( MEMDB==0 || pPager->tempFile );
63572 assert( isOpen(pPager->fd) || pPager->tempFile );
63573 if( 0==pagerFlushOnCommit(pPager, 1) ){
63577 sqlite3BackupRestart(pPager->pBackup);
63580 if( pagerUseWal(pPager) ){
63582 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63586 rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
63592 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
63596 sqlite3PcacheCleanAll(pPager->pPCache);
63604 sqlite3_file *fd = pPager->fd;
63607 && !pPager->noSync
63608 && sqlite3JournalIsInMemory(pPager->jfd);
63639 assert( isOpen(pPager->jfd)
63640 || pPager->journalMode==PAGER_JOURNALMODE_OFF
63641 || pPager->journalMode==PAGER_JOURNALMODE_WAL
63643 if( !zSuper && isOpen(pPager->jfd)
63644 && pPager->journalOff==jrnlBufferSize(pPager)
63645 && pPager->dbSize>=pPager->dbOrigSize
63646 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
63654 rc = pager_incr_changecounter(pPager, 1);
63656 rc = sqlite3JournalCreate(pPager->jfd);
63658 rc = pager_incr_changecounter(pPager, 0);
63665 rc = sqlite3JournalCreate(pPager->jfd);
63670 rc = pager_incr_changecounter(pPager, 0);
63678 rc = writeSuperJournal(pPager, zSuper);
63692 rc = syncJournal(pPager, 0);
63695 pList = sqlite3PcacheDirtyList(pPager->pPCache);
63700 rc = pager_write_pagelist(pPager, pList);
63701 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbFileSize ){
63702 char *pTmp = pPager->pTmpSpace;
63703 int szPage = (int)pPager->pageSize;
63705 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage,
63706 ((i64)pPager->dbSize*pPager->pageSize)-szPage);
63717 rc = sqlite3JournalCreate(pPager->jfd);
63719 sqlite3OsClose(pPager->jfd);
63724 sqlite3OsClose(pPager->jfd);
63730 rc = pager_write_pagelist(pPager, pList);
63736 sqlite3PcacheCleanAll(pPager->pPCache);
63744 if( pPager->dbSize>pPager->dbFileSize ){
63745 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
63746 assert( pPager->eState==PAGER_WRITER_DBMOD );
63747 rc = pager_truncate(pPager, nNew);
63753 rc = sqlite3PagerSync(pPager, zSuper);
63755 IOTRACE(("DBSYNC %p\n", pPager))
63760 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
63761 pPager->eState = PAGER_WRITER_FINISHED;
63782 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
63788 if( NEVER(pPager->errCode) ) return pPager->errCode;
63789 pPager->iDataVersion++;
63791 assert( pPager->eState==PAGER_WRITER_LOCKED
63792 || pPager->eState==PAGER_WRITER_FINISHED
63793 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
63795 assert( assert_pager_state(pPager) );
63808 if( pPager->eState==PAGER_WRITER_LOCKED
63809 && pPager->exclusiveMode
63810 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
63812 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
63813 pPager->eState = PAGER_READER;
63817 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
63818 rc = pager_end_transaction(pPager, pPager->setSuper, 1);
63819 return pager_error(pPager, rc);
63848 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
63850 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
63856 assert( assert_pager_state(pPager) );
63857 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
63858 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
63860 if( pagerUseWal(pPager) ){
63862 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
63863 rc2 = pager_end_transaction(pPager, pPager->setSuper, 0);
63865 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
63866 int eState = pPager->eState;
63867 rc = pager_end_transaction(pPager, 0, 0);
63873 pPager->errCode = SQLITE_ABORT;
63874 pPager->eState = PAGER_ERROR;
63875 setGetterMethod(pPager);
63879 rc = pager_playback(pPager, 0);
63882 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
63891 return pager_error(pPager, rc);
63898 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
63899 return pPager->readOnly;
63906 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
63907 return sqlite3PcacheRefCount(pPager->pPCache);
63915 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
63916 int perPageSize = pPager->pageSize + pPager->nExtra
63918 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
63919 + sqlite3MallocSize(pPager)
63920 + pPager->pageSize;
63934 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
63936 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
63937 a[1] = sqlite3PcachePagecount(pPager->pPCache);
63938 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
63939 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
63940 a[4] = pPager->eState;
63941 a[5] = pPager->errCode;
63942 a[6] = (int)pPager->aStat[PAGER_STAT_HIT] & 0x7fffffff;
63943 a[7] = (int)pPager->aStat[PAGER_STAT_MISS] & 0x7fffffff;
63945 a[9] = pPager->nRead;
63946 a[10] = (int)pPager->aStat[PAGER_STAT_WRITE] & 0x7fffffff;
63962 SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, u64 *pnVal){
63976 *pnVal += pPager->aStat[eStat];
63978 pPager->aStat[eStat] = 0;
63985 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
63986 return pPager->tempFile || pPager->memVfs;
63999 static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
64001 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
64005 assert( pPager->eState>=PAGER_WRITER_LOCKED );
64006 assert( assert_pager_state(pPager) );
64007 assert( nSavepoint>nCurrent && pPager->useJournal );
64014 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
64020 pPager->aSavepoint = aNew;
64024 aNew[ii].nOrig = pPager->dbSize;
64025 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
64026 aNew[ii].iOffset = pPager->journalOff;
64028 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
64030 aNew[ii].iSubRec = pPager->nSubRec;
64031 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
64036 if( pagerUseWal(pPager) ){
64037 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
64039 pPager->nSavepoint = ii+1;
64041 assert( pPager->nSavepoint==nSavepoint );
64042 assertTruncateConstraint(pPager);
64045 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
64046 assert( pPager->eState>=PAGER_WRITER_LOCKED );
64047 assert( assert_pager_state(pPager) );
64049 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
64050 return pagerOpenSavepoint(pPager, nSavepoint);
64087 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
64088 int rc = pPager->errCode;
64097 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
64106 for(ii=nNew; ii<pPager->nSavepoint; ii++){
64107 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
64109 pPager->nSavepoint = nNew;
64114 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
64115 if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){
64117 if( sqlite3JournalIsInMemory(pPager->sjfd) ){
64118 i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec;
64119 rc = sqlite3OsTruncate(pPager->sjfd, sz);
64122 pPager->nSubRec = pRel->iSubRec;
64130 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
64131 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
64132 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
64142 pPager->journalMode==PAGER_JOURNALMODE_OFF
64143 && pPager->eState>=PAGER_WRITER_CACHEMOD
64145 pPager->errCode = SQLITE_ABORT;
64146 pPager->eState = PAGER_ERROR;
64147 setGetterMethod(pPager);
64168 SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){
64170 if( nullIfMemDb && (pPager->memDb || sqlite3IsMemdb(pPager->pVfs)) ){
64173 return pPager->zFilename;
64180 SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
64181 return pPager->pVfs;
64189 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
64190 return pPager->fd;
64197 SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
64199 return pPager->jfd;
64201 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
64208 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
64209 return pPager->zJournal;
64238 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
64245 assert( pPager->eState==PAGER_WRITER_CACHEMOD
64246 || pPager->eState==PAGER_WRITER_DBMOD
64248 assert( assert_pager_state(pPager) );
64253 assert( pPager->tempFile || !MEMDB );
64254 if( pPager->tempFile ){
64284 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
64285 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
64296 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
64297 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
64307 pPgOld = sqlite3PagerLookup(pPager, pgno);
64315 if( pPager->tempFile ){
64318 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
64332 if( pPager->tempFile && pPgOld ){
64353 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
64355 if( needSyncPgno<=pPager->dbOrigSize ){
64356 assert( pPager->pTmpSpace!=0 );
64357 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
64386 assert( pPg->nRef>0 || pPg->pPager->memDb );
64408 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
64414 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
64415 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
64416 pPager->exclusiveMode = (u8)eMode;
64418 return (int)pPager->exclusiveMode;
64441 SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
64442 u8 eOld = pPager->journalMode; /* Prior journalmode */
64456 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
64471 assert( pPager->eState!=PAGER_ERROR );
64472 pPager->journalMode = (u8)eMode;
64485 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
64486 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
64495 sqlite3OsClose(pPager->jfd);
64496 if( pPager->eLock>=RESERVED_LOCK ){
64497 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
64500 int state = pPager->eState;
64503 rc = sqlite3PagerSharedLock(pPager);
64505 if( pPager->eState==PAGER_READER ){
64507 rc = pagerLockDb(pPager, RESERVED_LOCK);
64510 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
64513 pagerUnlockDb(pPager, SHARED_LOCK);
64515 pager_unlock(pPager);
64517 assert( state==pPager->eState );
64520 sqlite3OsClose(pPager->jfd);
64525 return (int)pPager->journalMode;
64531 SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
64532 return (int)pPager->journalMode;
64540 SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
64541 assert( assert_pager_state(pPager) );
64542 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
64543 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
64553 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
64555 pPager->journalSizeLimit = iLimit;
64556 sqlite3WalLimit(pPager->pWal, iLimit);
64558 return pPager->journalSizeLimit;
64567 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
64568 return &pPager->pBackup;
64575 SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){
64576 assert( MEMDB==0 || pPager->tempFile );
64577 if( pPager->tempFile==0 ) pager_reset(pPager);
64591 Pager *pPager, /* Checkpoint on this pager */
64598 if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){
64610 if( pPager->pWal ){
64611 rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
64612 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
64613 pPager->pBusyHandlerArg,
64614 pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
64621 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
64622 return sqlite3WalCallback(pPager->pWal);
64629 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
64630 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
64631 if( pPager->noLock ) return 0;
64632 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
64639 static int pagerExclusiveLock(Pager *pPager){
64643 assert( pPager->eLock>=SHARED_LOCK );
64644 eOrigLock = pPager->eLock;
64645 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
64649 pagerUnlockDb(pPager, eOrigLock);
64661 static int pagerOpenWal(Pager *pPager){
64664 assert( pPager->pWal==0 && pPager->tempFile==0 );
64665 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
64672 if( pPager->exclusiveMode ){
64673 rc = pagerExclusiveLock(pPager);
64680 rc = sqlite3WalOpen(pPager->pVfs,
64681 pPager->fd, pPager->zWal, pPager->exclusiveMode,
64682 pPager->journalSizeLimit, &pPager->pWal
64685 pagerFixMaplimit(pPager);
64707 Pager *pPager, /* Pager object */
64712 assert( assert_pager_state(pPager) );
64713 assert( pPager->eState==PAGER_OPEN || pbOpen );
64714 assert( pPager->eState==PAGER_READER || !pbOpen );
64716 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
64718 if( !pPager->tempFile && !pPager->pWal ){
64719 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
64722 sqlite3OsClose(pPager->jfd);
64724 rc = pagerOpenWal(pPager);
64726 pPager->journalMode = PAGER_JOURNALMODE_WAL;
64727 pPager->eState = PAGER_OPEN;
64745 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
64748 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
64754 if( !pPager->pWal ){
64756 rc = pagerLockDb(pPager, SHARED_LOCK);
64759 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
64763 rc = pagerOpenWal(pPager);
64770 if( rc==SQLITE_OK && pPager->pWal ){
64771 rc = pagerExclusiveLock(pPager);
64773 rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
64774 pPager->pageSize, (u8*)pPager->pTmpSpace);
64775 pPager->pWal = 0;
64776 pagerFixMaplimit(pPager);
64777 if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
64790 SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager *pPager, int bLock){
64792 if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){
64793 rc = sqlite3WalWriteLock(pPager->pWal, bLock);
64802 SQLITE_PRIVATE void sqlite3PagerWalDb(Pager *pPager, sqlite3 *db){
64803 if( pagerUseWal(pPager) ){
64804 sqlite3WalDb(pPager->pWal, db);
64814 SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){
64816 if( pPager->pWal ){
64817 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
64828 Pager *pPager,
64832 if( pPager->pWal ){
64833 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
64844 SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager){
64846 if( pPager->pWal ){
64847 rc = sqlite3WalSnapshotRecover(pPager->pWal);
64866 SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){
64868 if( pPager->pWal ){
64869 rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
64880 SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){
64881 assert( pPager->pWal );
64882 sqlite3WalSnapshotUnlock(pPager->pWal);
64896 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){
64897 assert( pPager->eState>=PAGER_READER );
64898 return sqlite3WalFramesize(pPager->pWal);
64903 SQLITE_PRIVATE int sqlite3PagerWalSystemErrno(Pager *pPager){
64904 return sqlite3WalSystemErrno(pPager->pWal);
69938 Pager *pPager; /* The page cache */
70208 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
70683 p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
71622 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
71672 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
72227 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
72876 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
72890 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
72927 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
73162 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
73163 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
73215 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
73218 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
73219 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
73226 sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
73231 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
73268 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
73330 if( pBt && pBt->pPager ){
73331 sqlite3PagerClose(pBt->pPager, 0);
73347 pFile = sqlite3PagerFile(pBt->pPager);
73492 sqlite3PagerClose(pBt->pPager, p->db);
73523 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
73543 res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
73557 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
73579 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
73627 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
73686 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
73788 sqlite3PagerSetFlags(pBt->pPager,
73818 rc = sqlite3PagerSharedLock(pBt->pPager);
73827 sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
73871 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
73929 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
74027 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
74132 Pager *pPager = pBt->pPager;
74148 && sqlite3PagerIsreadonly(pPager)==0
74196 sqlite3PagerWalDb(pPager, p->db);
74203 rc = sqlite3PagerWalWriteLock(pPager, 1);
74221 rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db));
74234 (void)sqlite3PagerWalWriteLock(pPager, 0);
74239 sqlite3PagerWalDb(pPager, 0);
74294 rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint);
74319 return sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
74451 Pager *pPager = pBt->pPager;
74463 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
74701 Pager *pPager;
74708 pPager = pBt->pPager;
74709 VVA_ONLY( nRef = sqlite3PagerRefcount(pPager); )
74772 sqlite3PagerRollback(pPager);
74776 assert( nRef>=sqlite3PagerRefcount(pPager) );
74824 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
74827 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zSuperJrnl, 0);
74913 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
75003 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
75044 rc2 = sqlite3PagerRollback(pBt->pPager);
75098 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
75126 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
75755 && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */
75758 sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
75771 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,
78102 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
78332 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
80181 Pager *pSrcPager = pSrc->pBt->pPager;
80880 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion;
81002 return p->pBt->pPager;
81162 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
81600 VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
81605 sCheck.pPager = pBt->pPager;
81714 assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
81728 assert( p->pBt->pPager!=0 );
81729 return sqlite3PagerFilename(p->pBt->pPager, 1);
81741 assert( p->pBt->pPager!=0 );
81742 return sqlite3PagerJournalname(p->pBt->pPager);
81771 rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt);
81988 sqlite3PagerClearCache(pBt->pPager);
87772 Pager *pPager; /* Pager associated with pBt */
87775 pPager = sqlite3BtreePager(pBt);
87777 && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
87778 && sqlite3PagerIsMemdb(pPager)==0
87783 rc = sqlite3PagerExclusiveLock(pPager);
100977 Pager *pPager; /* Pager associated with pBt */
100998 pPager = sqlite3BtreePager(pBt);
100999 eOld = sqlite3PagerGetJournalMode(pPager);
101002 if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
101005 zFilename = sqlite3PagerFilename(pPager, 1);
101012 || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
101035 rc = sqlite3PagerCloseWal(pPager, db);
101037 sqlite3PagerSetJournalMode(pPager, eNew);
101042 sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
101057 eNew = sqlite3PagerSetJournalMode(pPager, eNew);
120665 Pager *pPager;
120675 pPager = sqlite3BtreePager(pNew->pBt);
120676 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
139406 Pager *pPager;
139419 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
139420 sqlite3PagerLockingMode(pPager, eMode);
139424 pPager = sqlite3BtreePager(pDb->pBt);
139425 eMode = sqlite3PagerLockingMode(pPager, eMode);
139489 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139495 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
139805 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139807 sqlite3_file *pFile = sqlite3PagerFile(pPager);
139812 Pager *pPager = sqlite3BtreePager(pDb->pBt);
139813 sqlite3_file *pFile = sqlite3PagerFile(pPager);
180681 Pager *pPager = sqlite3BtreePager(pBt);
180682 sqlite3PagerShrink(pPager);
180707 Pager *pPager = sqlite3BtreePager(pBt);
180708 rc = sqlite3PagerFlush(pPager);
183839 Pager *pPager;
183842 pPager = sqlite3BtreePager(pBtree);
183843 assert( pPager!=0 );
183844 fd = sqlite3PagerFile(pPager);
183850 *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
183853 *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
183856 *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
184743 Pager *pPager = sqlite3BtreePager(pBt);
184747 rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot);
184757 rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot);
184761 sqlite3PagerSnapshotOpen(pPager, 0);
184764 sqlite3PagerSnapshotUnlock(pPager);
224052 Pager *pPager = sqlite3BtreePager(pBt);
224059 fd = sqlite3PagerFile(pPager);
224115 Pager *pPager = sqlite3BtreePager(pBt);
224128 sqlite3PagerPagecount(pPager, &nPage);
224492 Pager *pPager; /* Pager being read/written */
224697 pCsr->pPager = sqlite3BtreePager(pBt);
224713 rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
224736 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
224774 Pager *pPager;
224811 pPager = sqlite3BtreePager(pBt);
224812 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);