Lines Matching defs:pPager
14997 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3*);
15018 SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
15019 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
15038 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper);
15041 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
15042 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
15043 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
15046 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*);
15047 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
15048 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
15049 SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
15050 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);
15054 SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager);
15055 SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot);
15056 SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager);
15069 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno);
15073 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager);
16192 Pager *pPager; /* The pager this page is part of */
21865 Pager *pPager = sqlite3BtreePager(pBt);
21866 int nByte = sqlite3PagerMemUsed(pPager);
21962 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
21963 sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
48792 Pager *pPager = sqlite3BtreePager(pBt);
48797 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
49428 assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */
52890 ** the page number and the pPager->pageSize bytes of data for the page.
52907 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
52913 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
52924 # define MEMDB pPager->memDb
52943 ** if( isOpen(pPager->jfd) ){ ...
52947 ** if( pPager->jfd->pMethods ){ ...
52960 SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
52961 if( pPager->fd->pMethods==0 ) return 0;
52962 if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
52964 if( pPager->pWal ){
52967 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
52989 ** assert( assert_pager_state(pPager) );
52995 Pager *pPager = p;
53012 assert( p->tempFile==0 || pPager->changeCountDone );
53041 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
53047 assert( pPager->errCode==SQLITE_OK );
53048 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
53052 assert( pPager->errCode==SQLITE_OK );
53059 assert( pPager->errCode==SQLITE_OK );
53060 if( !pagerUseWal(pPager) ){
53063 assert( pPager->dbSize==pPager->dbOrigSize );
53064 assert( pPager->dbOrigSize==pPager->dbFileSize );
53065 assert( pPager->dbOrigSize==pPager->dbHintSize );
53066 assert( pPager->setSuper==0 );
53071 assert( pPager->errCode==SQLITE_OK );
53072 if( !pagerUseWal(pPager) ){
53084 assert( pPager->dbOrigSize==pPager->dbFileSize );
53085 assert( pPager->dbOrigSize==pPager->dbHintSize );
53090 assert( pPager->errCode==SQLITE_OK );
53091 assert( !pagerUseWal(pPager) );
53098 assert( pPager->dbOrigSize<=pPager->dbHintSize );
53103 assert( pPager->errCode==SQLITE_OK );
53104 assert( !pagerUseWal(pPager) );
53117 assert( pPager->errCode!=SQLITE_OK );
53118 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile );
53131 ** to "print *pPager" in gdb:
53133 ** (gdb) printf "%s", print_pager_state(pPager)
53192 static void setGetterMethod(Pager *pPager){
53193 if( pPager->errCode ){
53194 pPager->xGet = getPageError;
53196 }else if( USEFETCH(pPager) ){
53197 pPager->xGet = getPageMMap;
53200 pPager->xGet = getPageNormal;
53214 Pager *pPager = pPg->pPager;
53218 for(i=0; i<pPager->nSavepoint; i++){
53219 p = &pPager->aSavepoint[i];
53221 for(i=i+1; i<pPager->nSavepoint; i++){
53222 pPager->aSavepoint[i].bTruncateOnRelease = 0;
53234 static int pageInJournal(Pager *pPager, PgHdr *pPg){
53235 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
53280 static int pagerUnlockDb(Pager *pPager, int eLock){
53283 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
53285 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
53286 if( isOpen(pPager->fd) ){
53287 assert( pPager->eLock>=eLock );
53288 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
53289 if( pPager->eLock!=UNKNOWN_LOCK ){
53290 pPager->eLock = (u8)eLock;
53292 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
53294 pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */
53308 static int pagerLockDb(Pager *pPager, int eLock){
53312 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
53313 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
53314 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
53315 pPager->eLock = (u8)eLock;
53316 IOTRACE(("LOCK %p %d\n", pPager, eLock))
53341 static int jrnlBufferSize(Pager *pPager){
53348 assert( isOpen(pPager->fd) );
53349 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
53351 UNUSED_PARAMETER(pPager);
53355 if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
53362 int nSector = pPager->sectorSize;
53363 int szPage = pPager->pageSize;
53372 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
53396 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
53409 Pager *pPager = pPg->pPager;
53410 assert( pPager->eState!=PAGER_ERROR );
53422 ** When this is called the journal file for pager pPager must be open.
53489 ** following the value in pPager->journalOff, assuming a sector
53490 ** size of pPager->sectorSize bytes.
53502 static i64 journalHdrOffset(Pager *pPager){
53504 i64 c = pPager->journalOff;
53506 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
53508 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
53510 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
53535 static int zeroJournalHdr(Pager *pPager, int doTruncate){
53537 assert( isOpen(pPager->jfd) );
53538 assert( !sqlite3JournalIsInMemory(pPager->jfd) );
53539 if( pPager->journalOff ){
53540 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
53542 IOTRACE(("JZEROHDR %p\n", pPager))
53544 rc = sqlite3OsTruncate(pPager->jfd, 0);
53547 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
53549 if( rc==SQLITE_OK && !pPager->noSync ){
53550 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
53561 rc = sqlite3OsFileSize(pPager->jfd, &sz);
53563 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
53585 static int writeJournalHdr(Pager *pPager){
53587 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
53588 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
53592 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
53594 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
53595 nHeader = JOURNAL_HDR_SZ(pPager);
53602 for(ii=0; ii<pPager->nSavepoint; ii++){
53603 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
53604 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
53608 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
53630 assert( isOpen(pPager->fd) || pPager->noSync );
53631 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
53632 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
53641 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
53642 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
53644 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
53646 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
53649 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
53676 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
53677 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
53678 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
53679 assert( pPager->journalHdr <= pPager->journalOff );
53680 pPager->journalOff += nHeader;
53690 ** pPager->journalOff. See comments above function writeJournalHdr() for
53695 ** database before the transaction began, in pages. Also, pPager->cksumInit
53704 Pager *pPager, /* Pager object */
53714 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
53720 pPager->journalOff = journalHdrOffset(pPager);
53721 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
53724 iHdrOff = pPager->journalOff;
53731 if( isHot || iHdrOff!=pPager->journalHdr ){
53732 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
53745 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
53746 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
53747 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
53752 if( pPager->journalOff==0 ){
53757 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
53758 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
53768 iPageSize = pPager->pageSize;
53792 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
53801 pPager->sectorSize = iSectorSize;
53804 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
53811 ** pPager at the current location. The super-journal name must be the last
53828 static int writeSuperJournal(Pager *pPager, const char *zSuper){
53835 assert( pPager->setSuper==0 );
53836 assert( !pagerUseWal(pPager) );
53839 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
53840 || !isOpen(pPager->jfd)
53844 pPager->setSuper = 1;
53845 assert( pPager->journalHdr <= pPager->journalOff );
53856 if( pPager->fullSync ){
53857 pPager->journalOff = journalHdrOffset(pPager);
53859 iHdrOff = pPager->journalOff;
53864 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
53865 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
53866 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
53867 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
53868 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8,
53873 pPager->journalOff += (nSuper+20);
53885 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
53886 && jrnlSize>pPager->journalOff
53888 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
53896 static void pager_reset(Pager *pPager){
53897 pPager->iDataVersion++;
53898 sqlite3BackupRestart(pPager->pBackup);
53899 sqlite3PcacheClear(pPager->pPCache);
53903 ** Return the pPager->iDataVersion value
53905 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){
53906 return pPager->iDataVersion;
53914 static void releaseAllSavepoints(Pager *pPager){
53916 for(ii=0; ii<pPager->nSavepoint; ii++){
53917 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
53919 if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){
53920 sqlite3OsClose(pPager->sjfd);
53922 sqlite3_free(pPager->aSavepoint);
53923 pPager->aSavepoint = 0;
53924 pPager->nSavepoint = 0;
53925 pPager->nSubRec = 0;
53933 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
53937 for(ii=0; ii<pPager->nSavepoint; ii++){
53938 PagerSavepoint *p = &pPager->aSavepoint[ii];
53965 static void pager_unlock(Pager *pPager){
53967 assert( pPager->eState==PAGER_READER
53968 || pPager->eState==PAGER_OPEN
53969 || pPager->eState==PAGER_ERROR
53972 sqlite3BitvecDestroy(pPager->pInJournal);
53973 pPager->pInJournal = 0;
53974 releaseAllSavepoints(pPager);
53976 if( pagerUseWal(pPager) ){
53977 assert( !isOpen(pPager->jfd) );
53978 sqlite3WalEndReadTransaction(pPager->pWal);
53979 pPager->eState = PAGER_OPEN;
53980 }else if( !pPager->exclusiveMode ){
53982 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
53996 || 1!=(pPager->journalMode & 5)
53998 sqlite3OsClose(pPager->jfd);
54006 rc = pagerUnlockDb(pPager, NO_LOCK);
54007 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
54008 pPager->eLock = UNKNOWN_LOCK;
54015 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
54016 pPager->eState = PAGER_OPEN;
54024 assert( pPager->errCode==SQLITE_OK || !MEMDB );
54025 if( pPager->errCode ){
54026 if( pPager->tempFile==0 ){
54027 pager_reset(pPager);
54028 pPager->changeCountDone = 0;
54029 pPager->eState = PAGER_OPEN;
54031 pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER);
54033 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
54034 pPager->errCode = SQLITE_OK;
54035 setGetterMethod(pPager);
54038 pPager->journalOff = 0;
54039 pPager->journalHdr = 0;
54040 pPager->setSuper = 0;
54062 static int pager_error(Pager *pPager, int rc){
54066 pPager->errCode==SQLITE_FULL ||
54067 pPager->errCode==SQLITE_OK ||
54068 (pPager->errCode & 0xff)==SQLITE_IOERR
54071 pPager->errCode = rc;
54072 pPager->eState = PAGER_ERROR;
54073 setGetterMethod(pPager);
54078 static int pager_truncate(Pager *pPager, Pgno nPage);
54081 ** The write transaction open on pPager is being committed (bCommit==1)
54096 static int pagerFlushOnCommit(Pager *pPager, int bCommit){
54097 if( pPager->tempFile==0 ) return 1;
54099 if( !isOpen(pPager->fd) ) return 0;
54100 return (sqlite3PCachePercentDirty(pPager->pPCache)>=25);
54156 static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){
54173 assert( assert_pager_state(pPager) );
54174 assert( pPager->eState!=PAGER_ERROR );
54175 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
54179 releaseAllSavepoints(pPager);
54180 assert( isOpen(pPager->jfd) || pPager->pInJournal==0
54181 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
54183 if( isOpen(pPager->jfd) ){
54184 assert( !pagerUseWal(pPager) );
54187 if( sqlite3JournalIsInMemory(pPager->jfd) ){
54188 /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */
54189 sqlite3OsClose(pPager->jfd);
54190 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
54191 if( pPager->journalOff==0 ){
54194 rc = sqlite3OsTruncate(pPager->jfd, 0);
54195 if( rc==SQLITE_OK && pPager->fullSync ){
54201 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
54204 pPager->journalOff = 0;
54205 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
54206 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
54208 rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile);
54209 pPager->journalOff = 0;
54216 int bDelete = !pPager->tempFile;
54217 assert( sqlite3JournalIsInMemory(pPager->jfd)==0 );
54218 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
54219 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
54220 || pPager->journalMode==PAGER_JOURNALMODE_WAL
54222 sqlite3OsClose(pPager->jfd);
54224 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
54230 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
54231 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
54232 PgHdr *p = sqlite3PagerLookup(pPager, 1);
54240 sqlite3BitvecDestroy(pPager->pInJournal);
54241 pPager->pInJournal = 0;
54242 pPager->nRec = 0;
54244 if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){
54245 sqlite3PcacheCleanAll(pPager->pPCache);
54247 sqlite3PcacheClearWritable(pPager->pPCache);
54249 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
54252 if( pagerUseWal(pPager) ){
54257 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
54259 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
54266 assert( pPager->eLock==EXCLUSIVE_LOCK );
54267 rc = pager_truncate(pPager, pPager->dbSize);
54271 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
54275 if( !pPager->exclusiveMode
54276 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
54278 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
54280 pPager->eState = PAGER_READER;
54281 pPager->setSuper = 0;
54303 static void pagerUnlockAndRollback(Pager *pPager){
54304 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
54305 assert( assert_pager_state(pPager) );
54306 if( pPager->eState>=PAGER_WRITER_LOCKED ){
54308 sqlite3PagerRollback(pPager);
54310 }else if( !pPager->exclusiveMode ){
54311 assert( pPager->eState==PAGER_READER );
54312 pager_end_transaction(pPager, 0, 0);
54315 pager_unlock(pPager);
54319 ** Parameter aData must point to a buffer of pPager->pageSize bytes
54321 ** page of data and the current value of pPager->cksumInit.
54324 ** random initial value (pPager->cksumInit) and every 200th byte
54325 ** of the page data, starting with byte offset (pPager->pageSize%200).
54337 static u32 pager_cksum(Pager *pPager, const u8 *aData){
54338 u32 cksum = pPager->cksumInit; /* Checksum value to return */
54339 int i = pPager->pageSize-200; /* Loop counter */
54385 Pager *pPager, /* The pager being played back */
54404 aData = pPager->pTmpSpace;
54406 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
54414 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
54415 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
54417 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
54422 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
54425 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
54427 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
54434 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
54438 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
54444 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
54458 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
54459 pPager->nReserve = ((u8*)aData)[20];
54497 if( pagerUseWal(pPager) ){
54500 pPg = sqlite3PagerLookup(pPager, pgno);
54503 assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile );
54505 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
54509 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
54513 if( isOpen(pPager->fd)
54514 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
54517 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
54519 assert( !pagerUseWal(pPager) );
54527 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
54529 if( pgno>pPager->dbFileSize ){
54530 pPager->dbFileSize = pgno;
54532 if( pPager->pBackup ){
54533 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
54553 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
54554 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
54555 rc = sqlite3PagerGet(pPager, pgno, &pPg, 1);
54556 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
54557 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
54570 memcpy(pData, (u8*)aData, pPager->pageSize);
54571 pPager->xReiniter(pPg);
54581 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
54631 static int pager_delsuper(Pager *pPager, const char *zSuper){
54632 sqlite3_vfs *pVfs = pPager->pVfs;
54736 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
54749 static int pager_truncate(Pager *pPager, Pgno nPage){
54751 assert( pPager->eState!=PAGER_ERROR );
54752 assert( pPager->eState!=PAGER_READER );
54754 if( isOpen(pPager->fd)
54755 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
54758 int szPage = pPager->pageSize;
54759 assert( pPager->eLock==EXCLUSIVE_LOCK );
54761 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
54765 rc = sqlite3OsTruncate(pPager->fd, newSize);
54767 char *pTmp = pPager->pTmpSpace;
54771 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
54774 pPager->dbFileSize = nPage;
54812 ** pPager->sectorSize is to define the "blast radius" of bytes that
54819 static void setSectorSize(Pager *pPager){
54820 assert( isOpen(pPager->fd) || pPager->tempFile );
54822 if( pPager->tempFile
54823 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
54829 pPager->sectorSize = 512;
54831 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
54855 ** + pPager->pageSize bytes of data.
54892 static int pager_playback(Pager *pPager, int isHot){
54893 sqlite3_vfs *pVfs = pPager->pVfs;
54903 u32 savedPageSize = pPager->pageSize;
54908 assert( isOpen(pPager->jfd) );
54909 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
54921 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
54925 zSuper = pPager->pTmpSpace;
54926 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
54934 pPager->journalOff = 0;
54947 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
54961 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
54962 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
54980 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
54981 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
54987 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
54988 rc = pager_truncate(pPager, mxPg);
54992 pPager->dbSize = mxPg;
55000 pager_reset(pPager);
55003 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
55008 pPager->journalOff = szJ;
55034 rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1);
55042 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
55054 pPager->changeCountDone = pPager->tempFile;
55061 zSuper = &pPager->pTmpSpace[4];
55062 rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1);
55066 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
55068 rc = sqlite3PagerSync(pPager, 0);
55071 rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0);
55078 assert( zSuper==&pPager->pTmpSpace[4] );
55080 rc = pager_delsuper(pPager, zSuper);
55085 nPlayback, pPager->zJournal);
55092 setSectorSize(pPager);
55110 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
55116 assert( pPager->eState>=PAGER_READER && !MEMDB );
55117 assert( isOpen(pPager->fd) );
55119 if( pagerUseWal(pPager) ){
55120 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
55124 rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData);
55128 i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize;
55129 rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
55142 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
55149 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
55152 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
55156 PAGER_INCR(pPager->nRead);
55157 IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno));
55159 PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)));
55170 ** needed, as determined by the pPager->changeCountDone state variable.
55176 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
55201 Pager *pPager = (Pager *)pCtx;
55204 assert( pagerUseWal(pPager) );
55205 pPg = sqlite3PagerLookup(pPager, iPg);
55212 pPager->xReiniter(pPg);
55226 sqlite3BackupRestart(pPager->pBackup);
55234 static int pagerRollbackWal(Pager *pPager){
55245 pPager->dbSize = pPager->dbOrigSize;
55246 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
55247 pList = sqlite3PcacheDirtyList(pPager->pPCache);
55250 rc = pagerUndoCallback((void *)pPager, pList->pgno);
55267 Pager *pPager, /* Pager object */
55276 assert( pPager->pWal );
55303 pPager->aStat[PAGER_STAT_WRITE] += nList;
55306 rc = sqlite3WalFrames(pPager->pWal,
55307 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
55309 if( rc==SQLITE_OK && pPager->pBackup ){
55311 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
55316 pList = sqlite3PcacheDirtyList(pPager->pPCache);
55333 static int pagerBeginReadTransaction(Pager *pPager){
55337 assert( pagerUseWal(pPager) );
55338 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
55345 sqlite3WalEndReadTransaction(pPager->pWal);
55347 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
55349 pager_reset(pPager);
55350 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
55366 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
55375 assert( pPager->eState==PAGER_OPEN );
55376 assert( pPager->eLock>=SHARED_LOCK );
55377 assert( isOpen(pPager->fd) );
55378 assert( pPager->tempFile==0 );
55379 nPage = sqlite3WalDbsize(pPager->pWal);
55386 if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
55388 int rc = sqlite3OsFileSize(pPager->fd, &n);
55392 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
55399 if( nPage>pPager->mxPgno ){
55400 pPager->mxPgno = (Pgno)nPage;
55409 ** Check if the *-wal file that corresponds to the database opened by pPager
55426 static int pagerOpenWalIfPresent(Pager *pPager){
55428 assert( pPager->eState==PAGER_OPEN );
55429 assert( pPager->eLock>=SHARED_LOCK );
55431 if( !pPager->tempFile ){
55434 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
55440 rc = pagerPagecount(pPager, &nPage);
55443 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
55445 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
55446 rc = sqlite3PagerOpenWal(pPager, 0);
55448 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
55449 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
55493 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
55499 assert( pPager->eState!=PAGER_ERROR );
55500 assert( pPager->eState>=PAGER_WRITER_LOCKED );
55513 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
55514 pPager->changeCountDone = pPager->tempFile;
55516 if( !pSavepoint && pagerUseWal(pPager) ){
55517 return pagerRollbackWal(pPager);
55520 /* Use pPager->journalOff as the effective size of the main rollback
55523 ** past pPager->journalOff is off-limits to us.
55525 szJ = pPager->journalOff;
55526 assert( pagerUseWal(pPager)==0 || szJ==0 );
55531 ** greater than the current database size (pPager->dbSize) but those
55535 if( pSavepoint && !pagerUseWal(pPager) ){
55537 pPager->journalOff = pSavepoint->iOffset;
55538 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
55539 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
55543 pPager->journalOff = 0;
55551 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
55555 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
55559 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
55564 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
55566 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
55568 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
55569 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
55573 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
55581 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
55583 if( pagerUseWal(pPager) ){
55584 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
55586 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
55587 assert( offset==(i64)ii*(4+pPager->pageSize) );
55588 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
55595 pPager->journalOff = szJ;
55605 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
55606 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
55613 SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){
55614 return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage);
55620 static void pagerFixMaplimit(Pager *pPager){
55622 sqlite3_file *fd = pPager->fd;
55625 sz = pPager->szMmap;
55626 pPager->bUseFetch = (sz>0);
55627 setGetterMethod(pPager);
55628 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
55636 SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
55637 pPager->szMmap = szMmap;
55638 pagerFixMaplimit(pPager);
55644 SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){
55645 sqlite3PcacheShrink(pPager->pPCache);
55701 Pager *pPager, /* The pager to set safety level for */
55705 if( pPager->tempFile ){
55706 pPager->noSync = 1;
55707 pPager->fullSync = 0;
55708 pPager->extraSync = 0;
55710 pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0;
55711 pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
55712 pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
55714 if( pPager->noSync ){
55715 pPager->syncFlags = 0;
55717 pPager->syncFlags = SQLITE_SYNC_FULL;
55719 pPager->syncFlags = SQLITE_SYNC_NORMAL;
55721 pPager->walSyncFlags = (pPager->syncFlags<<2);
55722 if( pPager->fullSync ){
55723 pPager->walSyncFlags |= pPager->syncFlags;
55725 if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){
55726 pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2);
55729 pPager->doNotSpill &= ~SPILLFLAG_OFF;
55731 pPager->doNotSpill |= SPILLFLAG_OFF;
55761 Pager *pPager, /* The pager object */
55773 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
55800 Pager *pPager, /* Pager object */
55805 pPager->xBusyHandler = xBusyHandler;
55806 pPager->pBusyHandlerArg = pBusyHandlerArg;
55807 ap = (void **)&pPager->xBusyHandler;
55810 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
55843 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
55858 if( (pPager->memDb==0 || pPager->dbSize==0)
55859 && sqlite3PcacheRefCount(pPager->pPCache)==0
55860 && pageSize && pageSize!=(u32)pPager->pageSize
55865 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
55866 rc = sqlite3OsFileSize(pPager->fd, &nByte);
55880 pager_reset(pPager);
55881 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
55884 sqlite3PageFree(pPager->pTmpSpace);
55885 pPager->pTmpSpace = pNew;
55886 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
55887 pPager->pageSize = pageSize;
55893 *pPageSize = pPager->pageSize;
55895 if( nReserve<0 ) nReserve = pPager->nReserve;
55897 pPager->nReserve = (i16)nReserve;
55898 pagerFixMaplimit(pPager);
55911 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
55912 return pPager->pTmpSpace;
55922 SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){
55924 pPager->mxPgno = mxPage;
55926 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
55927 /* assert( pPager->mxPgno>=pPager->dbSize ); */
55931 return pPager->mxPgno;
55972 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
55975 assert( isOpen(pPager->fd) || pPager->tempFile );
55981 assert( !pagerUseWal(pPager) );
55983 if( isOpen(pPager->fd) ){
55984 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
55985 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
56000 SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
56001 assert( pPager->eState>=PAGER_READER );
56002 assert( pPager->eState!=PAGER_WRITER_FINISHED );
56003 *pnPage = (int)pPager->dbSize;
56021 static int pager_wait_on_lock(Pager *pPager, int locktype){
56029 assert( (pPager->eLock>=locktype)
56030 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
56031 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
56035 rc = pagerLockDb(pPager, locktype);
56036 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
56041 ** Function assertTruncateConstraint(pPager) checks that one of the
56065 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
56067 static void assertTruncateConstraint(Pager *pPager){
56068 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
56071 # define assertTruncateConstraint(pPager)
56085 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
56086 assert( pPager->dbSize>=nPage );
56087 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
56088 pPager->dbSize = nPage;
56104 ** syncs the journal file to disk, then sets pPager->journalHdr to the
56116 static int pagerSyncHotJournal(Pager *pPager){
56118 if( !pPager->noSync ){
56119 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
56122 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
56139 Pager *pPager, /* Pager object */
56146 if( pPager->pMmapFreelist ){
56147 *ppPage = p = pPager->pMmapFreelist;
56148 pPager->pMmapFreelist = p->pDirty;
56150 assert( pPager->nExtra>=8 );
56153 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
56155 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
56161 p->pPager = pPager;
56167 assert( p->pPager==pPager );
56172 pPager->nMmapOut++;
56183 Pager *pPager = pPg->pPager;
56184 pPager->nMmapOut--;
56185 pPg->pDirty = pPager->pMmapFreelist;
56186 pPager->pMmapFreelist = pPg;
56188 assert( pPager->fd->pMethods->iVersion>=3 );
56189 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
56195 static void pagerFreeMapHdrs(Pager *pPager){
56198 for(p=pPager->pMmapFreelist; p; p=pNext){
56209 static int databaseIsUnmoved(Pager *pPager){
56213 if( pPager->tempFile ) return SQLITE_OK;
56214 if( pPager->dbSize==0 ) return SQLITE_OK;
56215 assert( pPager->zFilename && pPager->zFilename[0] );
56216 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
56243 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){
56244 u8 *pTmp = (u8*)pPager->pTmpSpace;
56245 assert( db || pagerUseWal(pPager)==0 );
56246 assert( assert_pager_state(pPager) );
56249 pagerFreeMapHdrs(pPager);
56250 /* pPager->errCode = 0; */
56251 pPager->exclusiveMode = 0;
56255 assert( db || pPager->pWal==0 );
56257 && SQLITE_OK==databaseIsUnmoved(pPager)
56261 sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
56262 pPager->pWal = 0;
56265 pager_reset(pPager);
56267 pager_unlock(pPager);
56280 if( isOpen(pPager->jfd) ){
56281 pager_error(pPager, pagerSyncHotJournal(pPager));
56283 pagerUnlockAndRollback(pPager);
56287 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
56288 IOTRACE(("CLOSE %p\n", pPager))
56289 sqlite3OsClose(pPager->jfd);
56290 sqlite3OsClose(pPager->fd);
56292 sqlite3PcacheClose(pPager->pPCache);
56293 assert( !pPager->aSavepoint && !pPager->pInJournal );
56294 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
56296 sqlite3_free(pPager);
56351 static int syncJournal(Pager *pPager, int newHdr){
56354 assert( pPager->eState==PAGER_WRITER_CACHEMOD
56355 || pPager->eState==PAGER_WRITER_DBMOD
56357 assert( assert_pager_state(pPager) );
56358 assert( !pagerUseWal(pPager) );
56360 rc = sqlite3PagerExclusiveLock(pPager);
56363 if( !pPager->noSync ){
56364 assert( !pPager->tempFile );
56365 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
56366 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
56367 assert( isOpen(pPager->jfd) );
56397 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
56399 iNextHdrOffset = journalHdrOffset(pPager);
56400 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
56403 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
56420 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
56421 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
56422 IOTRACE(("JSYNC %p\n", pPager))
56423 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
56426 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
56428 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
56433 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
56434 IOTRACE(("JSYNC %p\n", pPager))
56435 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
56436 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
56441 pPager->journalHdr = pPager->journalOff;
56443 pPager->nRec = 0;
56444 rc = writeJournalHdr(pPager);
56448 pPager->journalHdr = pPager->journalOff;
56456 sqlite3PcacheClearSyncFlags(pPager->pPCache);
56457 pPager->eState = PAGER_WRITER_DBMOD;
56458 assert( assert_pager_state(pPager) );
56494 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
56498 assert( !pagerUseWal(pPager) );
56499 assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD );
56500 assert( pPager->eLock==EXCLUSIVE_LOCK );
56501 assert( isOpen(pPager->fd) || pList->pDirty==0 );
56507 if( !isOpen(pPager->fd) ){
56508 assert( pPager->tempFile && rc==SQLITE_OK );
56509 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
56515 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
56517 && pPager->dbHintSize<pPager->dbSize
56518 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
56520 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
56521 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
56522 pPager->dbHintSize = pPager->dbSize;
56536 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
56537 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
56546 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
56553 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
56555 if( pgno>pPager->dbFileSize ){
56556 pPager->dbFileSize = pgno;
56558 pPager->aStat[PAGER_STAT_WRITE]++;
56561 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
56564 PAGERID(pPager), pgno, pager_pagehash(pList)));
56565 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
56568 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
56585 static int openSubJournal(Pager *pPager){
56587 if( !isOpen(pPager->sjfd) ){
56592 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
56595 rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill);
56613 Pager *pPager = pPg->pPager;
56614 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
56617 assert( pPager->useJournal );
56618 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
56619 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
56620 assert( pagerUseWal(pPager)
56621 || pageInJournal(pPager, pPg)
56622 || pPg->pgno>pPager->dbOrigSize
56624 rc = openSubJournal(pPager);
56630 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
56633 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
56634 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
56636 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
56641 pPager->nSubRec++;
56642 assert( pPager->nSavepoint>0 );
56643 rc = addToSavepointBitvecs(pPager, pPg->pgno);
56675 Pager *pPager = (Pager *)p;
56678 assert( pPg->pPager==pPager );
56697 if( NEVER(pPager->errCode) ) return SQLITE_OK;
56698 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
56699 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
56700 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
56701 if( pPager->doNotSpill
56702 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
56708 pPager->aStat[PAGER_STAT_SPILL]++;
56710 if( pagerUseWal(pPager) ){
56714 rc = pagerWalFrames(pPager, pPg, 0, 0);
56719 if( pPager->tempFile==0 ){
56720 rc = sqlite3JournalCreate(pPager->jfd);
56721 if( rc!=SQLITE_OK ) return pager_error(pPager, rc);
56727 || pPager->eState==PAGER_WRITER_CACHEMOD
56729 rc = syncJournal(pPager, 1);
56735 rc = pager_write_pagelist(pPager, pPg);
56741 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
56745 return pager_error(pPager, rc);
56751 SQLITE_PRIVATE int sqlite3PagerFlush(Pager *pPager){
56752 int rc = pPager->errCode;
56754 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
56755 assert( assert_pager_state(pPager) );
56759 rc = pagerStress((void*)pPager, pList);
56810 Pager *pPager = 0; /* Pager object to allocate and return */
56940 ROUND8(sizeof(*pPager)) + /* Pager structure */
56944 sizeof(pPager) + /* Space to hold a pointer */
56959 pPager = (Pager*)pPtr; pPtr += ROUND8(sizeof(*pPager));
56960 pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize);
56961 pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile);
56962 pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
56963 pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize;
56964 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
56965 memcpy(pPtr, &pPager, sizeof(pPager)); pPtr += sizeof(pPager);
56967 /* Fill in the Pager.zFilename and pPager.zQueryParam fields */
56969 pPager->zFilename = (char*)pPtr;
56982 pPager->zJournal = (char*)pPtr;
56986 sqlite3FileSuffix3(zFilename,pPager->zJournal);
56987 pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1);
56990 pPager->zJournal = 0;
56996 pPager->zWal = (char*)pPtr;
57000 sqlite3FileSuffix3(zFilename, pPager->zWal);
57001 pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
57004 pPager->zWal = 0;
57009 pPager->pVfs = pVfs;
57010 pPager->vfsFlags = vfsFlags;
57016 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
57032 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
57034 setSectorSize(pPager);
57036 if( szPageDflt<pPager->sectorSize ){
57037 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
57040 szPageDflt = (u32)pPager->sectorSize;
57057 pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0);
57059 || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){
57077 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
57078 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
57079 pPager->noLock = 1; /* Do no locking */
57087 assert( pPager->memDb==0 );
57088 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
57097 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
57103 sqlite3OsClose(pPager->fd);
57104 sqlite3PageFree(pPager->pTmpSpace);
57105 sqlite3_free(pPager);
57109 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
57110 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
57112 pPager->useJournal = (u8)useJournal;
57113 /* pPager->stmtOpen = 0; */
57114 /* pPager->stmtInUse = 0; */
57115 /* pPager->nRef = 0; */
57116 /* pPager->stmtSize = 0; */
57117 /* pPager->stmtJSize = 0; */
57118 /* pPager->nPage = 0; */
57119 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
57120 /* pPager->state = PAGER_UNLOCK; */
57121 /* pPager->errMask = 0; */
57122 pPager->tempFile = (u8)tempFile;
57126 pPager->exclusiveMode = (u8)tempFile;
57127 pPager->changeCountDone = pPager->tempFile;
57128 pPager->memDb = (u8)memDb;
57129 pPager->readOnly = (u8)readOnly;
57130 assert( useJournal || pPager->tempFile );
57131 pPager->noSync = pPager->tempFile;
57132 if( pPager->noSync ){
57133 assert( pPager->fullSync==0 );
57134 assert( pPager->extraSync==0 );
57135 assert( pPager->syncFlags==0 );
57136 assert( pPager->walSyncFlags==0 );
57138 pPager->fullSync = 1;
57139 pPager->extraSync = 0;
57140 pPager->syncFlags = SQLITE_SYNC_NORMAL;
57141 pPager->walSyncFlags = SQLITE_SYNC_NORMAL | (SQLITE_SYNC_NORMAL<<2);
57143 /* pPager->pFirst = 0; */
57144 /* pPager->pFirstSynced = 0; */
57145 /* pPager->pLast = 0; */
57146 pPager->nExtra = (u16)nExtra;
57147 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
57148 assert( isOpen(pPager->fd) || tempFile );
57149 setSectorSize(pPager);
57151 pPager->journalMode = PAGER_JOURNALMODE_OFF;
57153 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
57155 /* pPager->xBusyHandler = 0; */
57156 /* pPager->pBusyHandlerArg = 0; */
57157 pPager->xReiniter = xReinit;
57158 setGetterMethod(pPager);
57159 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
57160 /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
57162 *ppPager = pPager;
57172 Pager *pPager;
57176 pPager = *(Pager**)(zName - 4 - sizeof(Pager*));
57177 return pPager->fd;
57212 static int hasHotJournal(Pager *pPager, int *pExists){
57213 sqlite3_vfs * const pVfs = pPager->pVfs;
57216 int jrnlOpen = !!isOpen(pPager->jfd);
57218 assert( pPager->useJournal );
57219 assert( isOpen(pPager->fd) );
57220 assert( pPager->eState==PAGER_OPEN );
57222 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
57228 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
57241 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
57245 assert( pPager->tempFile==0 );
57246 rc = pagerPagecount(pPager, &nPage);
57258 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
57259 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
57260 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
57272 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
57276 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
57281 sqlite3OsClose(pPager->jfd);
57332 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
57339 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
57340 assert( assert_pager_state(pPager) );
57341 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
57342 assert( pPager->errCode==SQLITE_OK );
57344 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
57348 assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
57350 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
57352 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
57359 if( pPager->eLock<=SHARED_LOCK ){
57360 rc = hasHotJournal(pPager, &bHotJournal);
57366 if( pPager->readOnly ){
57386 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
57404 if( !isOpen(pPager->jfd) ){
57405 sqlite3_vfs * const pVfs = pPager->pVfs;
57408 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
57412 assert( !pPager->tempFile );
57413 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
57414 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
57417 sqlite3OsClose(pPager->jfd);
57430 if( isOpen(pPager->jfd) ){
57432 rc = pagerSyncHotJournal(pPager);
57434 rc = pager_playback(pPager, !pPager->tempFile);
57435 pPager->eState = PAGER_OPEN;
57437 }else if( !pPager->exclusiveMode ){
57438 pagerUnlockDb(pPager, SHARED_LOCK);
57458 pager_error(pPager, rc);
57462 assert( pPager->eState==PAGER_OPEN );
57463 assert( (pPager->eLock==SHARED_LOCK)
57464 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
57468 if( !pPager->tempFile && pPager->hasHeldSharedLock ){
57485 char dbFileVers[sizeof(pPager->dbFileVers)];
57487 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
57488 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
57496 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
57497 pager_reset(pPager);
57505 if( USEFETCH(pPager) ){
57506 sqlite3OsUnfetch(pPager->fd, 0, 0);
57514 rc = pagerOpenWalIfPresent(pPager);
57516 assert( pPager->pWal==0 || rc==SQLITE_OK );
57520 if( pagerUseWal(pPager) ){
57522 rc = pagerBeginReadTransaction(pPager);
57525 if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
57526 rc = pagerPagecount(pPager, &pPager->dbSize);
57532 pager_unlock(pPager);
57533 assert( pPager->eState==PAGER_OPEN );
57535 pPager->eState = PAGER_READER;
57536 pPager->hasHeldSharedLock = 1;
57549 static void pagerUnlockIfUnused(Pager *pPager){
57550 if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){
57551 assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */
57552 pagerUnlockAndRollback(pPager);
57614 Pager *pPager, /* The pager open on the database file */
57624 assert( pPager->errCode==SQLITE_OK );
57625 assert( pPager->eState>=PAGER_READER );
57626 assert( assert_pager_state(pPager) );
57627 assert( pPager->hasHeldSharedLock==1 );
57630 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
57633 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
57640 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
57643 assert( pPg->pPager==pPager || pPg->pPager==0 );
57646 if( pPg->pPager && !noContent ){
57649 assert( pgno!=PAGER_MJ_PGNO(pPager) );
57650 pPager->aStat[PAGER_STAT_HIT]++;
57660 if( pgno==PAGER_MJ_PGNO(pPager) ){
57665 pPg->pPager = pPager;
57667 assert( !isOpen(pPager->fd) || !MEMDB );
57668 if( !isOpen(pPager->fd) || pPager->dbSize<pgno || noContent ){
57669 if( pgno>pPager->mxPgno ){
57681 if( pgno<=pPager->dbOrigSize ){
57682 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
57685 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
57689 memset(pPg->pData, 0, pPager->pageSize);
57690 IOTRACE(("ZERO %p %d\n", pPager, pgno));
57692 assert( pPg->pPager==pPager );
57693 pPager->aStat[PAGER_STAT_MISS]++;
57708 pagerUnlockIfUnused(pPager);
57716 Pager *pPager, /* The pager open on the database file */
57730 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
57733 assert( USEFETCH(pPager) );
57742 assert( pPager->eState>=PAGER_READER );
57743 assert( assert_pager_state(pPager) );
57744 assert( pPager->hasHeldSharedLock==1 );
57745 assert( pPager->errCode==SQLITE_OK );
57747 if( bMmapOk && pagerUseWal(pPager) ){
57748 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
57756 rc = sqlite3OsFetch(pPager->fd,
57757 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
57760 if( pPager->eState>PAGER_READER || pPager->tempFile ){
57761 pPg = sqlite3PagerLookup(pPager, pgno);
57764 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
57766 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
57779 return getPageNormal(pPager, pgno, ppPage, flags);
57785 Pager *pPager, /* The pager open on the database file */
57792 assert( pPager->errCode!=SQLITE_OK );
57794 return pPager->errCode;
57801 Pager *pPager, /* The pager open on the database file */
57806 return pPager->xGet(pPager, pgno, ppPage, flags);
57820 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
57822 assert( pPager!=0 );
57824 assert( pPager->pPCache!=0 );
57825 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
57826 assert( pPage==0 || pPager->hasHeldSharedLock );
57828 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
57844 TESTONLY( Pager *pPager = pPg->pPager; )
57853 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
57859 Pager *pPager;
57863 pPager = pPg->pPager;
57865 pagerUnlockIfUnused(pPager);
57873 ** Open the journal file for pager pPager and write a journal header
57890 static int pager_open_journal(Pager *pPager){
57892 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
57894 assert( pPager->eState==PAGER_WRITER_LOCKED );
57895 assert( assert_pager_state(pPager) );
57896 assert( pPager->pInJournal==0 );
57901 if( NEVER(pPager->errCode) ) return pPager->errCode;
57903 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
57904 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
57905 if( pPager->pInJournal==0 ){
57910 if( !isOpen(pPager->jfd) ){
57911 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
57912 sqlite3MemJournalOpen(pPager->jfd);
57917 if( pPager->tempFile ){
57922 nSpill = jrnlBufferSize(pPager);
57927 rc = databaseIsUnmoved(pPager);
57930 pVfs, pPager->zJournal, pPager->jfd, flags, nSpill
57934 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
57943 pPager->nRec = 0;
57944 pPager->journalOff = 0;
57945 pPager->setSuper = 0;
57946 pPager->journalHdr = 0;
57947 rc = writeJournalHdr(pPager);
57952 sqlite3BitvecDestroy(pPager->pInJournal);
57953 pPager->pInJournal = 0;
57955 assert( pPager->eState==PAGER_WRITER_LOCKED );
57956 pPager->eState = PAGER_WRITER_CACHEMOD;
57976 ** sub-journal is implemented in-memory if pPager is an in-memory database,
57979 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
57982 if( pPager->errCode ) return pPager->errCode;
57983 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
57984 pPager->subjInMemory = (u8)subjInMemory;
57986 if( ALWAYS(pPager->eState==PAGER_READER) ){
57987 assert( pPager->pInJournal==0 );
57989 if( pagerUseWal(pPager) ){
57993 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
57994 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
57998 (void)sqlite3WalExclusiveMode(pPager->pWal, 1);
58006 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
58013 rc = pagerLockDb(pPager, RESERVED_LOCK);
58015 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
58029 pPager->eState = PAGER_WRITER_LOCKED;
58030 pPager->dbHintSize = pPager->dbSize;
58031 pPager->dbFileSize = pPager->dbSize;
58032 pPager->dbOrigSize = pPager->dbSize;
58033 pPager->journalOff = 0;
58036 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
58037 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
58038 assert( assert_pager_state(pPager) );
58041 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
58049 Pager *pPager = pPg->pPager;
58053 i64 iOff = pPager->journalOff;
58058 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
58060 assert( pPager->journalHdr<=pPager->journalOff );
58062 cksum = pager_cksum(pPager, (u8*)pData2);
58073 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
58075 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
58077 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
58080 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
58081 pPager->journalOff, pPager->pageSize));
58084 PAGERID(pPager), pPg->pgno,
58087 pPager->journalOff += 8 + pPager->pageSize;
58088 pPager->nRec++;
58089 assert( pPager->pInJournal!=0 );
58090 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
58093 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
58106 Pager *pPager = pPg->pPager;
58113 assert( pPager->eState==PAGER_WRITER_LOCKED
58114 || pPager->eState==PAGER_WRITER_CACHEMOD
58115 || pPager->eState==PAGER_WRITER_DBMOD
58117 assert( assert_pager_state(pPager) );
58118 assert( pPager->errCode==0 );
58119 assert( pPager->readOnly==0 );
58131 if( pPager->eState==PAGER_WRITER_LOCKED ){
58132 rc = pager_open_journal(pPager);
58135 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
58136 assert( assert_pager_state(pPager) );
58145 assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) );
58146 if( pPager->pInJournal!=0
58147 && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0
58149 assert( pagerUseWal(pPager)==0 );
58150 if( pPg->pgno<=pPager->dbOrigSize ){
58156 if( pPager->eState!=PAGER_WRITER_DBMOD ){
58160 PAGERID(pPager), pPg->pgno,
58175 if( pPager->nSavepoint>0 ){
58180 if( pPager->dbSize<pPg->pgno ){
58181 pPager->dbSize = pPg->pgno;
58204 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
58205 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
58212 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
58213 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
58221 nPageCount = pPager->dbSize;
58236 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
58237 if( pg!=PAGER_MJ_PGNO(pPager) ){
58238 rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
58247 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
58264 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
58272 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
58273 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
58292 Pager *pPager = pPg->pPager;
58294 assert( pPager->eState>=PAGER_WRITER_LOCKED );
58295 assert( assert_pager_state(pPager) );
58296 if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
58297 if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
58299 }else if( pPager->errCode ){
58300 return pPager->errCode;
58301 }else if( pPager->sectorSize > (u32)pPager->pageSize ){
58302 assert( pPager->tempFile==0 );
58341 Pager *pPager = pPg->pPager;
58342 if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
58343 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
58344 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
58358 ** But this only happens if the pPager->changeCountDone flag is false.
58374 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
58377 assert( pPager->eState==PAGER_WRITER_CACHEMOD
58378 || pPager->eState==PAGER_WRITER_DBMOD
58380 assert( assert_pager_state(pPager) );
58400 if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
58403 assert( !pPager->tempFile && isOpen(pPager->fd) );
58406 rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0);
58425 assert( pPager->dbFileSize>0 );
58428 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
58429 pPager->aStat[PAGER_STAT_WRITE]++;
58436 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
58437 pPager->changeCountDone = 1;
58440 pPager->changeCountDone = 1;
58457 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){
58460 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
58462 if( rc==SQLITE_OK && !pPager->noSync ){
58464 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
58480 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
58481 int rc = pPager->errCode;
58482 assert( assert_pager_state(pPager) );
58484 assert( pPager->eState==PAGER_WRITER_CACHEMOD
58485 || pPager->eState==PAGER_WRITER_DBMOD
58486 || pPager->eState==PAGER_WRITER_LOCKED
58488 assert( assert_pager_state(pPager) );
58489 if( 0==pagerUseWal(pPager) ){
58490 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
58497 ** Sync the database file for the pager pPager. zSuper points to the name
58523 Pager *pPager, /* Pager object */
58529 assert( pPager->eState==PAGER_WRITER_LOCKED
58530 || pPager->eState==PAGER_WRITER_CACHEMOD
58531 || pPager->eState==PAGER_WRITER_DBMOD
58532 || pPager->eState==PAGER_ERROR
58534 assert( assert_pager_state(pPager) );
58537 if( NEVER(pPager->errCode) ) return pPager->errCode;
58543 pPager->zFilename, zSuper, pPager->dbSize));
58546 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
58548 assert( MEMDB==0 || pPager->tempFile );
58549 assert( isOpen(pPager->fd) || pPager->tempFile );
58550 if( 0==pagerFlushOnCommit(pPager, 1) ){
58554 sqlite3BackupRestart(pPager->pBackup);
58557 if( pagerUseWal(pPager) ){
58559 pList = sqlite3PcacheDirtyList(pPager->pPCache);
58563 rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0);
58569 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
58573 sqlite3PcacheCleanAll(pPager->pPCache);
58581 sqlite3_file *fd = pPager->fd;
58584 && !pPager->noSync
58585 && sqlite3JournalIsInMemory(pPager->jfd);
58616 assert( isOpen(pPager->jfd)
58617 || pPager->journalMode==PAGER_JOURNALMODE_OFF
58618 || pPager->journalMode==PAGER_JOURNALMODE_WAL
58620 if( !zSuper && isOpen(pPager->jfd)
58621 && pPager->journalOff==jrnlBufferSize(pPager)
58622 && pPager->dbSize>=pPager->dbOrigSize
58623 && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
58631 rc = pager_incr_changecounter(pPager, 1);
58633 rc = sqlite3JournalCreate(pPager->jfd);
58635 rc = pager_incr_changecounter(pPager, 0);
58642 rc = sqlite3JournalCreate(pPager->jfd);
58647 rc = pager_incr_changecounter(pPager, 0);
58655 rc = writeSuperJournal(pPager, zSuper);
58669 rc = syncJournal(pPager, 0);
58672 pList = sqlite3PcacheDirtyList(pPager->pPCache);
58677 rc = pager_write_pagelist(pPager, pList);
58687 rc = sqlite3JournalCreate(pPager->jfd);
58689 sqlite3OsClose(pPager->jfd);
58694 sqlite3OsClose(pPager->jfd);
58700 rc = pager_write_pagelist(pPager, pList);
58706 sqlite3PcacheCleanAll(pPager->pPCache);
58714 if( pPager->dbSize>pPager->dbFileSize ){
58715 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
58716 assert( pPager->eState==PAGER_WRITER_DBMOD );
58717 rc = pager_truncate(pPager, nNew);
58723 rc = sqlite3PagerSync(pPager, zSuper);
58725 IOTRACE(("DBSYNC %p\n", pPager))
58730 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
58731 pPager->eState = PAGER_WRITER_FINISHED;
58752 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
58758 if( NEVER(pPager->errCode) ) return pPager->errCode;
58759 pPager->iDataVersion++;
58761 assert( pPager->eState==PAGER_WRITER_LOCKED
58762 || pPager->eState==PAGER_WRITER_FINISHED
58763 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
58765 assert( assert_pager_state(pPager) );
58778 if( pPager->eState==PAGER_WRITER_LOCKED
58779 && pPager->exclusiveMode
58780 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
58782 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
58783 pPager->eState = PAGER_READER;
58787 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
58788 rc = pager_end_transaction(pPager, pPager->setSuper, 1);
58789 return pager_error(pPager, rc);
58818 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
58820 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
58826 assert( assert_pager_state(pPager) );
58827 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
58828 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
58830 if( pagerUseWal(pPager) ){
58832 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
58833 rc2 = pager_end_transaction(pPager, pPager->setSuper, 0);
58835 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
58836 int eState = pPager->eState;
58837 rc = pager_end_transaction(pPager, 0, 0);
58843 pPager->errCode = SQLITE_ABORT;
58844 pPager->eState = PAGER_ERROR;
58845 setGetterMethod(pPager);
58849 rc = pager_playback(pPager, 0);
58852 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
58861 return pager_error(pPager, rc);
58868 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
58869 return pPager->readOnly;
58874 ** Return the sum of the reference counts for all pages held by pPager.
58876 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
58877 return sqlite3PcacheRefCount(pPager->pPCache);
58885 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
58886 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
58888 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
58889 + sqlite3MallocSize(pPager)
58890 + pPager->pageSize;
58904 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
58906 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
58907 a[1] = sqlite3PcachePagecount(pPager->pPCache);
58908 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
58909 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
58910 a[4] = pPager->eState;
58911 a[5] = pPager->errCode;
58912 a[6] = pPager->aStat[PAGER_STAT_HIT];
58913 a[7] = pPager->aStat[PAGER_STAT_MISS];
58914 a[8] = 0; /* Used to be pPager->nOvfl */
58915 a[9] = pPager->nRead;
58916 a[10] = pPager->aStat[PAGER_STAT_WRITE];
58932 SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
58946 *pnVal += pPager->aStat[eStat];
58948 pPager->aStat[eStat] = 0;
58955 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
58956 return pPager->tempFile;
58969 static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){
58971 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
58975 assert( pPager->eState>=PAGER_WRITER_LOCKED );
58976 assert( assert_pager_state(pPager) );
58977 assert( nSavepoint>nCurrent && pPager->useJournal );
58984 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
58990 pPager->aSavepoint = aNew;
58994 aNew[ii].nOrig = pPager->dbSize;
58995 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
58996 aNew[ii].iOffset = pPager->journalOff;
58998 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
59000 aNew[ii].iSubRec = pPager->nSubRec;
59001 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
59006 if( pagerUseWal(pPager) ){
59007 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
59009 pPager->nSavepoint = ii+1;
59011 assert( pPager->nSavepoint==nSavepoint );
59012 assertTruncateConstraint(pPager);
59015 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
59016 assert( pPager->eState>=PAGER_WRITER_LOCKED );
59017 assert( assert_pager_state(pPager) );
59019 if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){
59020 return pagerOpenSavepoint(pPager, nSavepoint);
59057 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
59058 int rc = pPager->errCode;
59067 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
59076 for(ii=nNew; ii<pPager->nSavepoint; ii++){
59077 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
59079 pPager->nSavepoint = nNew;
59084 PagerSavepoint *pRel = &pPager->aSavepoint[nNew];
59085 if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){
59087 if( sqlite3JournalIsInMemory(pPager->sjfd) ){
59088 i64 sz = (pPager->pageSize+4)*pRel->iSubRec;
59089 rc = sqlite3OsTruncate(pPager->sjfd, sz);
59092 pPager->nSubRec = pRel->iSubRec;
59100 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
59101 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
59102 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
59112 pPager->journalMode==PAGER_JOURNALMODE_OFF
59113 && pPager->eState>=PAGER_WRITER_CACHEMOD
59115 pPager->errCode = SQLITE_ABORT;
59116 pPager->eState = PAGER_ERROR;
59117 setGetterMethod(pPager);
59138 SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){
59140 return (nullIfMemDb && pPager->memDb) ? &zFake[4] : pPager->zFilename;
59146 SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
59147 return pPager->pVfs;
59155 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
59156 return pPager->fd;
59163 SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){
59165 return pPager->jfd;
59167 return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd;
59174 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
59175 return pPager->zJournal;
59204 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
59211 assert( pPager->eState==PAGER_WRITER_CACHEMOD
59212 || pPager->eState==PAGER_WRITER_DBMOD
59214 assert( assert_pager_state(pPager) );
59219 assert( pPager->tempFile || !MEMDB );
59220 if( pPager->tempFile ){
59250 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
59251 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
59262 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
59263 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
59273 pPgOld = sqlite3PagerLookup(pPager, pgno);
59281 if( pPager->tempFile ){
59284 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
59298 if( pPager->tempFile && pPgOld ){
59319 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0);
59321 if( needSyncPgno<=pPager->dbOrigSize ){
59322 assert( pPager->pTmpSpace!=0 );
59323 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
59352 assert( pPg->nRef>0 || pPg->pPager->memDb );
59374 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
59380 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
59381 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
59382 pPager->exclusiveMode = (u8)eMode;
59384 return (int)pPager->exclusiveMode;
59407 SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
59408 u8 eOld = pPager->journalMode; /* Prior journalmode */
59422 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
59437 assert( pPager->eState!=PAGER_ERROR );
59438 pPager->journalMode = (u8)eMode;
59451 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
59452 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
59462 sqlite3OsClose(pPager->jfd);
59463 if( pPager->eLock>=RESERVED_LOCK ){
59464 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
59467 int state = pPager->eState;
59470 rc = sqlite3PagerSharedLock(pPager);
59472 if( pPager->eState==PAGER_READER ){
59474 rc = pagerLockDb(pPager, RESERVED_LOCK);
59477 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
59480 pagerUnlockDb(pPager, SHARED_LOCK);
59482 pager_unlock(pPager);
59484 assert( state==pPager->eState );
59487 sqlite3OsClose(pPager->jfd);
59492 return (int)pPager->journalMode;
59498 SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
59499 return (int)pPager->journalMode;
59507 SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
59508 assert( assert_pager_state(pPager) );
59509 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
59510 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
59520 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
59522 pPager->journalSizeLimit = iLimit;
59523 sqlite3WalLimit(pPager->pWal, iLimit);
59525 return pPager->journalSizeLimit;
59529 ** Return a pointer to the pPager->pBackup variable. The backup module
59534 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
59535 return &pPager->pBackup;
59542 SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){
59543 assert( MEMDB==0 || pPager->tempFile );
59544 if( pPager->tempFile==0 ) pager_reset(pPager);
59558 Pager *pPager, /* Checkpoint on this pager */
59565 if( pPager->pWal ){
59566 rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
59567 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
59568 pPager->pBusyHandlerArg,
59569 pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
59576 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
59577 return sqlite3WalCallback(pPager->pWal);
59584 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
59585 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
59586 if( pPager->noLock ) return 0;
59587 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
59594 static int pagerExclusiveLock(Pager *pPager){
59597 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
59598 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
59602 pagerUnlockDb(pPager, SHARED_LOCK);
59614 static int pagerOpenWal(Pager *pPager){
59617 assert( pPager->pWal==0 && pPager->tempFile==0 );
59618 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
59625 if( pPager->exclusiveMode ){
59626 rc = pagerExclusiveLock(pPager);
59633 rc = sqlite3WalOpen(pPager->pVfs,
59634 pPager->fd, pPager->zWal, pPager->exclusiveMode,
59635 pPager->journalSizeLimit, &pPager->pWal
59638 pagerFixMaplimit(pPager);
59660 Pager *pPager, /* Pager object */
59665 assert( assert_pager_state(pPager) );
59666 assert( pPager->eState==PAGER_OPEN || pbOpen );
59667 assert( pPager->eState==PAGER_READER || !pbOpen );
59669 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
59671 if( !pPager->tempFile && !pPager->pWal ){
59672 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
59675 sqlite3OsClose(pPager->jfd);
59677 rc = pagerOpenWal(pPager);
59679 pPager->journalMode = PAGER_JOURNALMODE_WAL;
59680 pPager->eState = PAGER_OPEN;
59698 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
59701 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
59707 if( !pPager->pWal ){
59709 rc = pagerLockDb(pPager, SHARED_LOCK);
59712 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
59716 rc = pagerOpenWal(pPager);
59723 if( rc==SQLITE_OK && pPager->pWal ){
59724 rc = pagerExclusiveLock(pPager);
59726 rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
59727 pPager->pageSize, (u8*)pPager->pTmpSpace);
59728 pPager->pWal = 0;
59729 pagerFixMaplimit(pPager);
59730 if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
59738 ** If pager pPager is a wal-mode database not in exclusive locking mode,
59743 SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager *pPager, int bLock){
59745 if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){
59746 rc = sqlite3WalWriteLock(pPager->pWal, bLock);
59755 SQLITE_PRIVATE void sqlite3PagerWalDb(Pager *pPager, sqlite3 *db){
59756 if( pagerUseWal(pPager) ){
59757 sqlite3WalDb(pPager->pWal, db);
59767 SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){
59769 if( pPager->pWal ){
59770 rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot);
59781 Pager *pPager,
59785 if( pPager->pWal ){
59786 sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot);
59797 SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager){
59799 if( pPager->pWal ){
59800 rc = sqlite3WalSnapshotRecover(pPager->pWal);
59819 SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){
59821 if( pPager->pWal ){
59822 rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
59833 SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){
59834 assert( pPager->pWal );
59835 sqlite3WalSnapshotUnlock(pPager->pWal);
59849 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){
59850 assert( pPager->eState>=PAGER_READER );
59851 return sqlite3WalFramesize(pPager->pWal);
64283 u32 iBDataVersion; /* Combines with pBt->pPager->iDataVersion */
64331 ** global SQLITE_MUTEX_STATIC_MAIN mutex. The pPager field
64355 Pager *pPager; /* The page cache */
64625 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
65096 (int)p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0)
65972 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
66022 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0);
66358 ** of pPage. (pSrc and pPager are often the same.) If pCell contains a
66492 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
67101 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
67115 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
67165 rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
67414 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
67415 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
67464 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
67467 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
67468 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
67475 sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
67480 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
67517 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
67579 if( pBt && pBt->pPager ){
67580 sqlite3PagerClose(pBt->pPager, 0);
67596 pFile = sqlite3PagerFile(pBt->pPager);
67733 sqlite3PagerClose(pBt->pPager, p->db);
67764 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
67784 res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
67798 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
67820 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
67868 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
67927 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
68029 sqlite3PagerSetFlags(pBt->pPager,
68060 rc = sqlite3PagerSharedLock(pBt->pPager);
68069 sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
68113 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
68171 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
68264 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
68365 Pager *pPager = pBt->pPager;
68381 && sqlite3PagerIsreadonly(pPager)==0
68429 sqlite3PagerWalDb(pPager, p->db);
68436 rc = sqlite3PagerWalWriteLock(pPager, 1);
68454 rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db));
68467 (void)sqlite3PagerWalWriteLock(pPager, 0);
68472 sqlite3PagerWalDb(pPager, 0);
68527 rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint);
68659 Pager *pPager = pBt->pPager;
68671 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
68909 Pager *pPager = pBt->pPager;
68910 VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager); )
68948 sqlite3PagerRollback(pPager);
68952 assert( nRef>=sqlite3PagerRefcount(pPager) );
69000 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
69003 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zSuperJrnl, 0);
69089 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
69094 p->iBDataVersion--; /* Compensate for pPager->iDataVersion++; */
69179 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
69220 rc2 = sqlite3PagerRollback(pBt->pPager);
69274 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
69302 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
69920 && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */
69923 sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
69937 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage,
71954 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
72171 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
73955 Pager *pSrcPager = pSrc->pBt->pPager;
74624 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion;
74746 return p->pBt->pPager;
74868 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
75293 VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
75297 sCheck.pPager = pBt->pPager;
75408 assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
75422 assert( p->pBt->pPager!=0 );
75423 return sqlite3PagerFilename(p->pBt->pPager, 1);
75435 assert( p->pBt->pPager!=0 );
75436 return sqlite3PagerJournalname(p->pBt->pPager);
75465 rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt);
81052 Pager *pPager; /* Pager associated with pBt */
81055 pPager = sqlite3BtreePager(pBt);
81057 && aMJNeeded[sqlite3PagerGetJournalMode(pPager)]
81058 && sqlite3PagerIsMemdb(pPager)==0
81063 rc = sqlite3PagerExclusiveLock(pPager);
93157 Pager *pPager; /* Pager associated with pBt */
93161 const char *zFilename; /* Name of database file for pPager */
93178 pPager = sqlite3BtreePager(pBt);
93179 eOld = sqlite3PagerGetJournalMode(pPager);
93181 if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
93184 zFilename = sqlite3PagerFilename(pPager, 1);
93191 || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
93214 rc = sqlite3PagerCloseWal(pPager, db);
93216 sqlite3PagerSetJournalMode(pPager, eNew);
93221 sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
93236 eNew = sqlite3PagerSetJournalMode(pPager, eNew);
110889 Pager *pPager;
110899 pPager = sqlite3BtreePager(pNew->pBt);
110900 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
128195 Pager *pPager;
128208 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
128209 sqlite3PagerLockingMode(pPager, eMode);
128213 pPager = sqlite3BtreePager(pDb->pBt);
128214 eMode = sqlite3PagerLockingMode(pPager, eMode);
128278 Pager *pPager = sqlite3BtreePager(pDb->pBt);
128284 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
128588 Pager *pPager = sqlite3BtreePager(pDb->pBt);
128590 sqlite3_file *pFile = sqlite3PagerFile(pPager);
128595 Pager *pPager = sqlite3BtreePager(pDb->pBt);
128596 sqlite3_file *pFile = sqlite3PagerFile(pPager);
164928 Pager *pPager = sqlite3BtreePager(pBt);
164929 sqlite3PagerShrink(pPager);
164954 Pager *pPager = sqlite3BtreePager(pBt);
164955 rc = sqlite3PagerFlush(pPager);
167885 Pager *pPager;
167888 pPager = sqlite3BtreePager(pBtree);
167889 assert( pPager!=0 );
167890 fd = sqlite3PagerFile(pPager);
167896 *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
167899 *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
167902 *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
168607 Pager *pPager = sqlite3BtreePager(pBt);
168611 rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot);
168621 rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot);
168625 sqlite3PagerSnapshotOpen(pPager, 0);
168628 sqlite3PagerSnapshotUnlock(pPager);
204794 Pager *pPager = sqlite3BtreePager(pBt);
204801 fd = sqlite3PagerFile(pPager);
204825 Pager *pPager = sqlite3BtreePager(pBt);
204838 sqlite3PagerPagecount(pPager, &nPage);
204843 rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg, 0);
204915 rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg, 0);
205199 Pager *pPager; /* Pager being read/written */
205396 pCsr->pPager = sqlite3BtreePager(pBt);
205412 rc = sqlite3PagerGet(pCsr->pPager, 1, &pCsr->pPage1, 0);
205430 rc = sqlite3PagerGet(pCsr->pPager, pCsr->pgno, (DbPage**)&pDbPage, 0);
205467 Pager *pPager;
205501 pPager = sqlite3BtreePager(pBt);
205502 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pDbPage, 0);