Lines Matching refs:pPager
10229 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
10248 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
10250 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
10268 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster);
10271 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
10272 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
10273 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
10276 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*);
10277 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
10278 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
10279 SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
10280 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);
10284 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager);
10362 Pager *pPager; /* The pager this page is part of */ member
15205 Pager *pPager = sqlite3BtreePager(pBt); in sqlite3_db_status() local
15206 totalUsed += sqlite3PagerMemUsed(pPager); in sqlite3_db_status()
15295 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); in sqlite3_db_status() local
15296 sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); in sqlite3_db_status()
42394 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
42400 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
42411 # define MEMDB pPager->memDb
42448 static int pagerUseWal(Pager *pPager){
42449 return (pPager->pWal!=0);
42469 Pager *pPager = p;
42486 assert( p->tempFile==0 || pPager->changeCountDone );
42514 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
42520 assert( pPager->errCode==SQLITE_OK );
42521 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
42525 assert( pPager->errCode==SQLITE_OK );
42532 assert( pPager->errCode==SQLITE_OK );
42533 if( !pagerUseWal(pPager) ){
42536 assert( pPager->dbSize==pPager->dbOrigSize );
42537 assert( pPager->dbOrigSize==pPager->dbFileSize );
42538 assert( pPager->dbOrigSize==pPager->dbHintSize );
42539 assert( pPager->setMaster==0 );
42544 assert( pPager->errCode==SQLITE_OK );
42545 if( !pagerUseWal(pPager) ){
42557 assert( pPager->dbOrigSize==pPager->dbFileSize );
42558 assert( pPager->dbOrigSize==pPager->dbHintSize );
42563 assert( pPager->errCode==SQLITE_OK );
42564 assert( !pagerUseWal(pPager) );
42570 assert( pPager->dbOrigSize<=pPager->dbHintSize );
42575 assert( pPager->errCode==SQLITE_OK );
42576 assert( !pagerUseWal(pPager) );
42588 assert( pPager->errCode!=SQLITE_OK );
42589 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
42658 Pager *pPager = pPg->pPager;
42662 for(i=0; i<pPager->nSavepoint; i++){
42663 p = &pPager->aSavepoint[i];
42674 static int pageInJournal(Pager *pPager, PgHdr *pPg){
42675 return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
42719 static int pagerUnlockDb(Pager *pPager, int eLock){
42722 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
42724 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
42725 if( isOpen(pPager->fd) ){
42726 assert( pPager->eLock>=eLock );
42727 rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock);
42728 if( pPager->eLock!=UNKNOWN_LOCK ){
42729 pPager->eLock = (u8)eLock;
42731 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
42746 static int pagerLockDb(Pager *pPager, int eLock){
42750 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
42751 rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock);
42752 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
42753 pPager->eLock = (u8)eLock;
42754 IOTRACE(("LOCK %p %d\n", pPager, eLock))
42778 static int jrnlBufferSize(Pager *pPager){
42780 if( !pPager->tempFile ){
42785 assert( isOpen(pPager->fd) );
42786 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
42787 nSector = pPager->sectorSize;
42788 szPage = pPager->pageSize;
42797 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
42819 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
42832 Pager *pPager = pPg->pPager;
42833 assert( pPager->eState!=PAGER_ERROR );
42923 static i64 journalHdrOffset(Pager *pPager){
42925 i64 c = pPager->journalOff;
42927 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
42929 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
42931 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
42956 static int zeroJournalHdr(Pager *pPager, int doTruncate){
42958 assert( isOpen(pPager->jfd) );
42959 if( pPager->journalOff ){
42960 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
42962 IOTRACE(("JZEROHDR %p\n", pPager))
42964 rc = sqlite3OsTruncate(pPager->jfd, 0);
42967 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
42969 if( rc==SQLITE_OK && !pPager->noSync ){
42970 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
42981 rc = sqlite3OsFileSize(pPager->jfd, &sz);
42983 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
43005 static int writeJournalHdr(Pager *pPager){
43007 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
43008 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
43012 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
43014 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
43015 nHeader = JOURNAL_HDR_SZ(pPager);
43022 for(ii=0; ii<pPager->nSavepoint; ii++){
43023 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
43024 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
43028 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
43050 assert( isOpen(pPager->fd) || pPager->noSync );
43051 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
43052 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
43061 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
43062 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
43064 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
43066 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
43069 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
43096 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
43097 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
43098 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
43099 assert( pPager->journalHdr <= pPager->journalOff );
43100 pPager->journalOff += nHeader;
43124 Pager *pPager, /* Pager object */
43134 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
43140 pPager->journalOff = journalHdrOffset(pPager);
43141 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
43144 iHdrOff = pPager->journalOff;
43151 if( isHot || iHdrOff!=pPager->journalHdr ){
43152 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
43165 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
43166 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
43167 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
43172 if( pPager->journalOff==0 ){
43177 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
43178 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
43188 iPageSize = pPager->pageSize;
43212 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
43221 pPager->sectorSize = iSectorSize;
43224 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
43248 static int writeMasterJournal(Pager *pPager, const char *zMaster){
43255 assert( pPager->setMaster==0 );
43256 assert( !pagerUseWal(pPager) );
43259 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
43260 || !isOpen(pPager->jfd)
43264 pPager->setMaster = 1;
43265 assert( pPager->journalHdr <= pPager->journalOff );
43276 if( pPager->fullSync ){
43277 pPager->journalOff = journalHdrOffset(pPager);
43279 iHdrOff = pPager->journalOff;
43284 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
43285 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
43286 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
43287 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
43288 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
43292 pPager->journalOff += (nMaster+20);
43304 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
43305 && jrnlSize>pPager->journalOff
43307 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
43315 static void pager_reset(Pager *pPager){
43316 pPager->iDataVersion++;
43317 sqlite3BackupRestart(pPager->pBackup);
43318 sqlite3PcacheClear(pPager->pPCache);
43324 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){
43325 assert( pPager->eState>PAGER_OPEN );
43326 return pPager->iDataVersion;
43334 static void releaseAllSavepoints(Pager *pPager){
43336 for(ii=0; ii<pPager->nSavepoint; ii++){
43337 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
43339 if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
43340 sqlite3OsClose(pPager->sjfd);
43342 sqlite3_free(pPager->aSavepoint);
43343 pPager->aSavepoint = 0;
43344 pPager->nSavepoint = 0;
43345 pPager->nSubRec = 0;
43353 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
43357 for(ii=0; ii<pPager->nSavepoint; ii++){
43358 PagerSavepoint *p = &pPager->aSavepoint[ii];
43385 static void pager_unlock(Pager *pPager){
43387 assert( pPager->eState==PAGER_READER
43388 || pPager->eState==PAGER_OPEN
43389 || pPager->eState==PAGER_ERROR
43392 sqlite3BitvecDestroy(pPager->pInJournal);
43393 pPager->pInJournal = 0;
43394 releaseAllSavepoints(pPager);
43396 if( pagerUseWal(pPager) ){
43397 assert( !isOpen(pPager->jfd) );
43398 sqlite3WalEndReadTransaction(pPager->pWal);
43399 pPager->eState = PAGER_OPEN;
43400 }else if( !pPager->exclusiveMode ){
43402 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
43416 || 1!=(pPager->journalMode & 5)
43418 sqlite3OsClose(pPager->jfd);
43426 rc = pagerUnlockDb(pPager, NO_LOCK);
43427 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
43428 pPager->eLock = UNKNOWN_LOCK;
43435 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
43436 pPager->changeCountDone = 0;
43437 pPager->eState = PAGER_OPEN;
43445 if( pPager->errCode ){
43447 pager_reset(pPager);
43448 pPager->changeCountDone = pPager->tempFile;
43449 pPager->eState = PAGER_OPEN;
43450 pPager->errCode = SQLITE_OK;
43451 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
43454 pPager->journalOff = 0;
43455 pPager->journalHdr = 0;
43456 pPager->setMaster = 0;
43478 static int pager_error(Pager *pPager, int rc){
43482 pPager->errCode==SQLITE_FULL ||
43483 pPager->errCode==SQLITE_OK ||
43484 (pPager->errCode & 0xff)==SQLITE_IOERR
43487 pPager->errCode = rc;
43488 pPager->eState = PAGER_ERROR;
43493 static int pager_truncate(Pager *pPager, Pgno nPage);
43548 static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){
43565 assert( assert_pager_state(pPager) );
43566 assert( pPager->eState!=PAGER_ERROR );
43567 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
43571 releaseAllSavepoints(pPager);
43572 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
43573 if( isOpen(pPager->jfd) ){
43574 assert( !pagerUseWal(pPager) );
43577 if( sqlite3IsMemJournal(pPager->jfd) ){
43578 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
43579 sqlite3OsClose(pPager->jfd);
43580 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
43581 if( pPager->journalOff==0 ){
43584 rc = sqlite3OsTruncate(pPager->jfd, 0);
43585 if( rc==SQLITE_OK && pPager->fullSync ){
43591 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
43594 pPager->journalOff = 0;
43595 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
43596 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
43598 rc = zeroJournalHdr(pPager, hasMaster);
43599 pPager->journalOff = 0;
43606 int bDelete = (!pPager->tempFile && sqlite3JournalExists(pPager->jfd));
43607 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
43608 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
43609 || pPager->journalMode==PAGER_JOURNALMODE_WAL
43611 sqlite3OsClose(pPager->jfd);
43613 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
43619 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
43620 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
43621 PgHdr *p = sqlite3PagerLookup(pPager, 1);
43629 sqlite3BitvecDestroy(pPager->pInJournal);
43630 pPager->pInJournal = 0;
43631 pPager->nRec = 0;
43632 sqlite3PcacheCleanAll(pPager->pPCache);
43633 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
43635 if( pagerUseWal(pPager) ){
43640 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
43642 }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){
43649 assert( pPager->eLock==EXCLUSIVE_LOCK );
43650 rc = pager_truncate(pPager, pPager->dbSize);
43653 if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
43654 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
43658 if( !pPager->exclusiveMode
43659 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
43661 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
43662 pPager->changeCountDone = 0;
43664 pPager->eState = PAGER_READER;
43665 pPager->setMaster = 0;
43687 static void pagerUnlockAndRollback(Pager *pPager){
43688 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
43689 assert( assert_pager_state(pPager) );
43690 if( pPager->eState>=PAGER_WRITER_LOCKED ){
43692 sqlite3PagerRollback(pPager);
43694 }else if( !pPager->exclusiveMode ){
43695 assert( pPager->eState==PAGER_READER );
43696 pager_end_transaction(pPager, 0, 0);
43699 pager_unlock(pPager);
43721 static u32 pager_cksum(Pager *pPager, const u8 *aData){
43722 u32 cksum = pPager->cksumInit; /* Checksum value to return */
43723 int i = pPager->pageSize-200; /* Loop counter */
43736 static void pagerReportSize(Pager *pPager){
43737 if( pPager->xCodecSizeChng ){
43738 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
43739 (int)pPager->nReserve);
43784 Pager *pPager, /* The pager being played back */
43803 aData = pPager->pTmpSpace;
43805 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
43813 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
43814 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
43816 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
43821 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
43824 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
43826 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
43833 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
43837 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
43843 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
43857 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
43858 pPager->nReserve = ((u8*)aData)[20];
43859 pagerReportSize(pPager);
43897 if( pagerUseWal(pPager) ){
43900 pPg = sqlite3PagerLookup(pPager, pgno);
43903 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
43905 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
43909 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
43913 if( isOpen(pPager->fd)
43914 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
43917 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
43919 assert( !pagerUseWal(pPager) );
43920 rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
43921 if( pgno>pPager->dbFileSize ){
43922 pPager->dbFileSize = pgno;
43924 if( pPager->pBackup ){
43925 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
43926 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
43927 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
43947 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 );
43948 pPager->doNotSpill |= SPILLFLAG_ROLLBACK;
43949 rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
43950 assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 );
43951 pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK;
43965 memcpy(pData, (u8*)aData, pPager->pageSize);
43966 pPager->xReiniter(pPg);
43967 if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
43987 assert( !pagerUseWal(pPager) );
43995 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
43999 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
44048 static int pager_delmaster(Pager *pPager, const char *zMaster){
44049 sqlite3_vfs *pVfs = pPager->pVfs;
44158 static int pager_truncate(Pager *pPager, Pgno nPage){
44160 assert( pPager->eState!=PAGER_ERROR );
44161 assert( pPager->eState!=PAGER_READER );
44163 if( isOpen(pPager->fd)
44164 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
44167 int szPage = pPager->pageSize;
44168 assert( pPager->eLock==EXCLUSIVE_LOCK );
44170 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
44174 rc = sqlite3OsTruncate(pPager->fd, newSize);
44176 char *pTmp = pPager->pTmpSpace;
44180 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
44183 pPager->dbFileSize = nPage;
44228 static void setSectorSize(Pager *pPager){
44229 assert( isOpen(pPager->fd) || pPager->tempFile );
44231 if( pPager->tempFile
44232 || (sqlite3OsDeviceCharacteristics(pPager->fd) &
44238 pPager->sectorSize = 512;
44240 pPager->sectorSize = sqlite3SectorSize(pPager->fd);
44301 static int pager_playback(Pager *pPager, int isHot){
44302 sqlite3_vfs *pVfs = pPager->pVfs;
44316 assert( isOpen(pPager->jfd) );
44317 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
44333 zMaster = pPager->pTmpSpace;
44334 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
44342 pPager->journalOff = 0;
44355 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
44369 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
44370 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
44388 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
44389 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
44395 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
44396 rc = pager_truncate(pPager, mxPg);
44400 pPager->dbSize = mxPg;
44408 pager_reset(pPager);
44411 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
44416 pPager->journalOff = szJ;
44447 if( pPager->fd->pMethods ){
44448 sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
44461 pPager->changeCountDone = pPager->tempFile;
44464 zMaster = pPager->pTmpSpace;
44465 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
44469 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
44471 rc = sqlite3PagerSync(pPager, 0);
44474 rc = pager_end_transaction(pPager, zMaster[0]!='\0', 0);
44481 rc = pager_delmaster(pPager, zMaster);
44486 nPlayback, pPager->zJournal);
44493 setSectorSize(pPager);
44510 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
44513 int pgsz = pPager->pageSize; /* Number of bytes to read */
44515 assert( pPager->eState>=PAGER_READER && !MEMDB );
44516 assert( isOpen(pPager->fd) );
44521 rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData);
44525 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
44526 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
44546 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
44549 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
44552 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
44555 PAGER_INCR(pPager->nRead);
44556 IOTRACE(("PGIN %p %d\n", pPager, pgno));
44558 PAGERID(pPager), pgno, pager_pagehash(pPg)));
44575 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
44600 Pager *pPager = (Pager *)pCtx;
44603 assert( pagerUseWal(pPager) );
44604 pPg = sqlite3PagerLookup(pPager, iPg);
44610 rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
44615 pPager->xReiniter(pPg);
44629 sqlite3BackupRestart(pPager->pBackup);
44637 static int pagerRollbackWal(Pager *pPager){
44648 pPager->dbSize = pPager->dbOrigSize;
44649 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
44650 pList = sqlite3PcacheDirtyList(pPager->pPCache);
44653 rc = pagerUndoCallback((void *)pPager, pList->pgno);
44670 Pager *pPager, /* Pager object */
44679 assert( pPager->pWal );
44706 pPager->aStat[PAGER_STAT_WRITE] += nList;
44709 rc = sqlite3WalFrames(pPager->pWal,
44710 pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
44712 if( rc==SQLITE_OK && pPager->pBackup ){
44714 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
44719 pList = sqlite3PcacheDirtyList(pPager->pPCache);
44736 static int pagerBeginReadTransaction(Pager *pPager){
44740 assert( pagerUseWal(pPager) );
44741 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
44748 sqlite3WalEndReadTransaction(pPager->pWal);
44750 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
44752 pager_reset(pPager);
44753 if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
44769 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
44778 assert( pPager->eState==PAGER_OPEN );
44779 assert( pPager->eLock>=SHARED_LOCK );
44780 nPage = sqlite3WalDbsize(pPager->pWal);
44790 assert( isOpen(pPager->fd) || pPager->tempFile );
44791 if( isOpen(pPager->fd) ){
44792 int rc = sqlite3OsFileSize(pPager->fd, &n);
44797 nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
44804 if( nPage>pPager->mxPgno ){
44805 pPager->mxPgno = (Pgno)nPage;
44831 static int pagerOpenWalIfPresent(Pager *pPager){
44833 assert( pPager->eState==PAGER_OPEN );
44834 assert( pPager->eLock>=SHARED_LOCK );
44836 if( !pPager->tempFile ){
44840 rc = pagerPagecount(pPager, &nPage);
44843 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
44848 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
44853 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
44854 rc = sqlite3PagerOpenWal(pPager, 0);
44855 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
44856 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
44900 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
44906 assert( pPager->eState!=PAGER_ERROR );
44907 assert( pPager->eState>=PAGER_WRITER_LOCKED );
44920 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
44921 pPager->changeCountDone = pPager->tempFile;
44923 if( !pSavepoint && pagerUseWal(pPager) ){
44924 return pagerRollbackWal(pPager);
44932 szJ = pPager->journalOff;
44933 assert( pagerUseWal(pPager)==0 || szJ==0 );
44942 if( pSavepoint && !pagerUseWal(pPager) ){
44944 pPager->journalOff = pSavepoint->iOffset;
44945 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
44946 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
44950 pPager->journalOff = 0;
44958 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
44962 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
44971 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
44973 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
44975 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
44976 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
44980 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
44988 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
44990 if( pagerUseWal(pPager) ){
44991 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
44993 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
44994 assert( offset==(i64)ii*(4+pPager->pageSize) );
44995 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
45002 pPager->journalOff = szJ;
45011 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
45012 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
45018 static void pagerFixMaplimit(Pager *pPager){
45020 sqlite3_file *fd = pPager->fd;
45023 sz = pPager->szMmap;
45024 pPager->bUseFetch = (sz>0);
45025 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
45033 SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
45034 pPager->szMmap = szMmap;
45035 pagerFixMaplimit(pPager);
45041 SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){
45042 sqlite3PcacheShrink(pPager->pPCache);
45093 Pager *pPager, /* The pager to set safety level for */
45098 pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
45099 pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
45100 if( pPager->noSync ){
45101 pPager->syncFlags = 0;
45102 pPager->ckptSyncFlags = 0;
45104 pPager->syncFlags = SQLITE_SYNC_FULL;
45105 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
45107 pPager->syncFlags = SQLITE_SYNC_NORMAL;
45108 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
45110 pPager->syncFlags = SQLITE_SYNC_NORMAL;
45111 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
45113 pPager->walSyncFlags = pPager->syncFlags;
45114 if( pPager->fullSync ){
45115 pPager->walSyncFlags |= WAL_SYNC_TRANSACTIONS;
45118 pPager->doNotSpill &= ~SPILLFLAG_OFF;
45120 pPager->doNotSpill |= SPILLFLAG_OFF;
45150 Pager *pPager, /* The pager object */
45162 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
45189 Pager *pPager, /* Pager object */
45193 pPager->xBusyHandler = xBusyHandler;
45194 pPager->pBusyHandlerArg = pBusyHandlerArg;
45196 if( isOpen(pPager->fd) ){
45197 void **ap = (void **)&pPager->xBusyHandler;
45200 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
45234 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
45249 if( (pPager->memDb==0 || pPager->dbSize==0)
45250 && sqlite3PcacheRefCount(pPager->pPCache)==0
45251 && pageSize && pageSize!=(u32)pPager->pageSize
45256 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
45257 rc = sqlite3OsFileSize(pPager->fd, &nByte);
45265 pager_reset(pPager);
45266 rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
45269 sqlite3PageFree(pPager->pTmpSpace);
45270 pPager->pTmpSpace = pNew;
45271 pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
45272 pPager->pageSize = pageSize;
45278 *pPageSize = pPager->pageSize;
45280 if( nReserve<0 ) nReserve = pPager->nReserve;
45282 pPager->nReserve = (i16)nReserve;
45283 pagerReportSize(pPager);
45284 pagerFixMaplimit(pPager);
45297 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
45298 return pPager->pTmpSpace;
45308 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
45310 pPager->mxPgno = mxPage;
45312 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
45313 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
45314 return pPager->mxPgno;
45355 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
45358 assert( isOpen(pPager->fd) || pPager->tempFile );
45364 assert( !pagerUseWal(pPager) );
45366 if( isOpen(pPager->fd) ){
45367 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
45368 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
45383 SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
45384 assert( pPager->eState>=PAGER_READER );
45385 assert( pPager->eState!=PAGER_WRITER_FINISHED );
45386 *pnPage = (int)pPager->dbSize;
45404 static int pager_wait_on_lock(Pager *pPager, int locktype){
45412 assert( (pPager->eLock>=locktype)
45413 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
45414 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
45418 rc = pagerLockDb(pPager, locktype);
45419 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
45448 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
45450 static void assertTruncateConstraint(Pager *pPager){
45451 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
45454 # define assertTruncateConstraint(pPager)
45468 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
45469 assert( pPager->dbSize>=nPage );
45470 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
45471 pPager->dbSize = nPage;
45499 static int pagerSyncHotJournal(Pager *pPager){
45501 if( !pPager->noSync ){
45502 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
45505 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
45521 Pager *pPager, /* Pager object */
45528 if( pPager->pMmapFreelist ){
45529 *ppPage = p = pPager->pMmapFreelist;
45530 pPager->pMmapFreelist = p->pDirty;
45532 memset(p->pExtra, 0, pPager->nExtra);
45534 *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
45536 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
45542 p->pPager = pPager;
45548 assert( p->pPager==pPager );
45553 pPager->nMmapOut++;
45563 Pager *pPager = pPg->pPager;
45564 pPager->nMmapOut--;
45565 pPg->pDirty = pPager->pMmapFreelist;
45566 pPager->pMmapFreelist = pPg;
45568 assert( pPager->fd->pMethods->iVersion>=3 );
45569 sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
45575 static void pagerFreeMapHdrs(Pager *pPager){
45578 for(p=pPager->pMmapFreelist; p; p=pNext){
45599 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
45600 u8 *pTmp = (u8 *)pPager->pTmpSpace;
45602 assert( assert_pager_state(pPager) );
45605 pagerFreeMapHdrs(pPager);
45607 pPager->exclusiveMode = 0;
45609 sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
45610 pPager->pWal = 0;
45612 pager_reset(pPager);
45614 pager_unlock(pPager);
45627 if( isOpen(pPager->jfd) ){
45628 pager_error(pPager, pagerSyncHotJournal(pPager));
45630 pagerUnlockAndRollback(pPager);
45634 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
45635 IOTRACE(("CLOSE %p\n", pPager))
45636 sqlite3OsClose(pPager->jfd);
45637 sqlite3OsClose(pPager->fd);
45639 sqlite3PcacheClose(pPager->pPCache);
45642 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
45645 assert( !pPager->aSavepoint && !pPager->pInJournal );
45646 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
45648 sqlite3_free(pPager);
45703 static int syncJournal(Pager *pPager, int newHdr){
45706 assert( pPager->eState==PAGER_WRITER_CACHEMOD
45707 || pPager->eState==PAGER_WRITER_DBMOD
45709 assert( assert_pager_state(pPager) );
45710 assert( !pagerUseWal(pPager) );
45712 rc = sqlite3PagerExclusiveLock(pPager);
45715 if( !pPager->noSync ){
45716 assert( !pPager->tempFile );
45717 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
45718 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
45719 assert( isOpen(pPager->jfd) );
45749 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
45751 iNextHdrOffset = journalHdrOffset(pPager);
45752 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
45755 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
45772 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
45773 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
45774 IOTRACE(("JSYNC %p\n", pPager))
45775 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
45778 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
45780 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
45785 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
45786 IOTRACE(("JSYNC %p\n", pPager))
45787 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
45788 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
45793 pPager->journalHdr = pPager->journalOff;
45795 pPager->nRec = 0;
45796 rc = writeJournalHdr(pPager);
45800 pPager->journalHdr = pPager->journalOff;
45808 sqlite3PcacheClearSyncFlags(pPager->pPCache);
45809 pPager->eState = PAGER_WRITER_DBMOD;
45810 assert( assert_pager_state(pPager) );
45846 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
45850 assert( !pagerUseWal(pPager) );
45851 assert( pPager->eState==PAGER_WRITER_DBMOD );
45852 assert( pPager->eLock==EXCLUSIVE_LOCK );
45858 if( !isOpen(pPager->fd) ){
45859 assert( pPager->tempFile && rc==SQLITE_OK );
45860 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
45866 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
45868 && pPager->dbHintSize<pPager->dbSize
45869 && (pList->pDirty || pList->pgno>pPager->dbHintSize)
45871 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
45872 sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
45873 pPager->dbHintSize = pPager->dbSize;
45887 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
45888 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
45895 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
45898 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
45905 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
45907 if( pgno>pPager->dbFileSize ){
45908 pPager->dbFileSize = pgno;
45910 pPager->aStat[PAGER_STAT_WRITE]++;
45913 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
45916 PAGERID(pPager), pgno, pager_pagehash(pList)));
45917 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
45920 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
45937 static int openSubJournal(Pager *pPager){
45939 if( !isOpen(pPager->sjfd) ){
45940 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
45941 sqlite3MemJournalOpen(pPager->sjfd);
45943 rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
45964 Pager *pPager = pPg->pPager;
45965 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
45968 assert( pPager->useJournal );
45969 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
45970 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
45971 assert( pagerUseWal(pPager)
45972 || pageInJournal(pPager, pPg)
45973 || pPg->pgno>pPager->dbOrigSize
45975 rc = openSubJournal(pPager);
45981 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
45984 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
45985 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
45986 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
45988 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
45993 pPager->nSubRec++;
45994 assert( pPager->nSavepoint>0 );
45995 rc = addToSavepointBitvecs(pPager, pPg->pgno);
46020 Pager *pPager = (Pager *)p;
46023 assert( pPg->pPager==pPager );
46042 if( NEVER(pPager->errCode) ) return SQLITE_OK;
46043 testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK );
46044 testcase( pPager->doNotSpill & SPILLFLAG_OFF );
46045 testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC );
46046 if( pPager->doNotSpill
46047 && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0
46054 if( pagerUseWal(pPager) ){
46060 rc = pagerWalFrames(pPager, pPg, 0, 0);
46066 || pPager->eState==PAGER_WRITER_CACHEMOD
46068 rc = syncJournal(pPager, 1);
46099 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
46107 rc = pager_write_pagelist(pPager, pPg);
46113 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
46117 return pager_error(pPager, rc);
46161 Pager *pPager = 0; /* Pager object to allocate and return */
46253 ROUND8(sizeof(*pPager)) + /* Pager structure */
46268 pPager = (Pager*)(pPtr);
46269 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
46270 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
46271 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
46272 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
46273 pPager->zFilename = (char*)(pPtr += journalFileSize);
46274 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
46279 pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri);
46280 memcpy(pPager->zFilename, zPathname, nPathname);
46281 if( nUri ) memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
46282 memcpy(pPager->zJournal, zPathname, nPathname);
46283 memcpy(&pPager->zJournal[nPathname], "-journal\000", 8+2);
46284 sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal);
46286 pPager->zWal = &pPager->zJournal[nPathname+8+1];
46287 memcpy(pPager->zWal, zPathname, nPathname);
46288 memcpy(&pPager->zWal[nPathname], "-wal\000", 4+1);
46289 sqlite3FileSuffix3(pPager->zFilename, pPager->zWal);
46293 pPager->pVfs = pVfs;
46294 pPager->vfsFlags = vfsFlags;
46300 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
46313 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
46315 setSectorSize(pPager);
46317 if( szPageDflt<pPager->sectorSize ){
46318 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
46321 szPageDflt = (u32)pPager->sectorSize;
46338 pPager->noLock = sqlite3_uri_boolean(zFilename, "nolock", 0);
46358 pPager->eState = PAGER_READER; /* Pretend we already have a lock */
46359 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE locking mode */
46360 pPager->noLock = 1; /* Do no locking */
46368 assert( pPager->memDb==0 );
46369 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
46378 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
46384 sqlite3OsClose(pPager->fd);
46385 sqlite3PageFree(pPager->pTmpSpace);
46386 sqlite3_free(pPager);
46390 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
46391 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
46393 pPager->useJournal = (u8)useJournal;
46400 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
46403 pPager->tempFile = (u8)tempFile;
46407 pPager->exclusiveMode = (u8)tempFile;
46408 pPager->changeCountDone = pPager->tempFile;
46409 pPager->memDb = (u8)memDb;
46410 pPager->readOnly = (u8)readOnly;
46411 assert( useJournal || pPager->tempFile );
46412 pPager->noSync = pPager->tempFile;
46413 if( pPager->noSync ){
46414 assert( pPager->fullSync==0 );
46415 assert( pPager->syncFlags==0 );
46416 assert( pPager->walSyncFlags==0 );
46417 assert( pPager->ckptSyncFlags==0 );
46419 pPager->fullSync = 1;
46420 pPager->syncFlags = SQLITE_SYNC_NORMAL;
46421 pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS;
46422 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
46427 pPager->nExtra = (u16)nExtra;
46428 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
46429 assert( isOpen(pPager->fd) || tempFile );
46430 setSectorSize(pPager);
46432 pPager->journalMode = PAGER_JOURNALMODE_OFF;
46434 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
46438 pPager->xReiniter = xReinit;
46442 *ppPager = pPager;
46452 static int databaseIsUnmoved(Pager *pPager){
46456 if( pPager->tempFile ) return SQLITE_OK;
46457 if( pPager->dbSize==0 ) return SQLITE_OK;
46458 assert( pPager->zFilename && pPager->zFilename[0] );
46459 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
46503 static int hasHotJournal(Pager *pPager, int *pExists){
46504 sqlite3_vfs * const pVfs = pPager->pVfs;
46507 int jrnlOpen = !!isOpen(pPager->jfd);
46509 assert( pPager->useJournal );
46510 assert( isOpen(pPager->fd) );
46511 assert( pPager->eState==PAGER_OPEN );
46513 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
46519 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
46532 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
46536 rc = pagerPagecount(pPager, &nPage);
46548 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
46549 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
46550 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
46562 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
46566 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
46571 sqlite3OsClose(pPager->jfd);
46622 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
46630 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
46631 assert( assert_pager_state(pPager) );
46632 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
46633 if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
46635 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
46640 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
46642 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
46649 if( pPager->eLock<=SHARED_LOCK ){
46650 rc = hasHotJournal(pPager, &bHotJournal);
46656 if( pPager->readOnly ){
46676 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
46694 if( !isOpen(pPager->jfd) ){
46695 sqlite3_vfs * const pVfs = pPager->pVfs;
46698 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
46702 assert( !pPager->tempFile );
46703 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
46704 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
46707 sqlite3OsClose(pPager->jfd);
46720 if( isOpen(pPager->jfd) ){
46722 rc = pagerSyncHotJournal(pPager);
46724 rc = pager_playback(pPager, 1);
46725 pPager->eState = PAGER_OPEN;
46727 }else if( !pPager->exclusiveMode ){
46728 pagerUnlockDb(pPager, SHARED_LOCK);
46748 pager_error(pPager, rc);
46752 assert( pPager->eState==PAGER_OPEN );
46753 assert( (pPager->eLock==SHARED_LOCK)
46754 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
46758 if( !pPager->tempFile && pPager->hasBeenUsed ){
46776 char dbFileVers[sizeof(pPager->dbFileVers)];
46778 rc = pagerPagecount(pPager, &nPage);
46782 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
46783 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
46791 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
46792 pager_reset(pPager);
46800 if( USEFETCH(pPager) ){
46801 sqlite3OsUnfetch(pPager->fd, 0, 0);
46809 rc = pagerOpenWalIfPresent(pPager);
46811 assert( pPager->pWal==0 || rc==SQLITE_OK );
46815 if( pagerUseWal(pPager) ){
46817 rc = pagerBeginReadTransaction(pPager);
46820 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
46821 rc = pagerPagecount(pPager, &pPager->dbSize);
46827 pager_unlock(pPager);
46828 assert( pPager->eState==PAGER_OPEN );
46830 pPager->eState = PAGER_READER;
46843 static void pagerUnlockIfUnused(Pager *pPager){
46844 if( pPager->nMmapOut==0 && (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
46845 pagerUnlockAndRollback(pPager);
46900 Pager *pPager, /* The pager open on the database file */
46914 const int bMmapOk = (pgno!=1 && USEFETCH(pPager)
46915 && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY))
46917 && pPager->xCodec==0
46921 assert( pPager->eState>=PAGER_READER );
46922 assert( assert_pager_state(pPager) );
46928 pPager->hasBeenUsed = 1;
46932 if( pPager->errCode!=SQLITE_OK ){
46933 rc = pPager->errCode;
46935 if( bMmapOk && pagerUseWal(pPager) ){
46936 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
46943 rc = sqlite3OsFetch(pPager->fd,
46944 (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
46948 if( pPager->eState>PAGER_READER ){
46949 pPg = sqlite3PagerLookup(pPager, pgno);
46952 rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
46954 sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
46969 pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
46971 rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase);
46974 pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase);
46987 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
46989 if( (*ppPage)->pPager && !noContent ){
46992 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
46993 pPager->aStat[PAGER_STAT_HIT]++;
47001 pPg->pPager = pPager;
47005 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
47010 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
47011 if( pgno>pPager->mxPgno ){
47023 if( pgno<=pPager->dbOrigSize ){
47024 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
47027 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
47031 memset(pPg->pData, 0, pPager->pageSize);
47032 IOTRACE(("ZERO %p %d\n", pPager, pgno));
47034 if( pagerUseWal(pPager) && bMmapOk==0 ){
47035 rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
47038 assert( pPg->pPager==pPager );
47039 pPager->aStat[PAGER_STAT_MISS]++;
47055 pagerUnlockIfUnused(pPager);
47072 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
47074 assert( pPager!=0 );
47076 assert( pPager->pPCache!=0 );
47077 pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0);
47078 assert( pPage==0 || pPager->hasBeenUsed );
47079 return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage);
47091 Pager *pPager;
47093 pPager = pPg->pPager;
47099 pagerUnlockIfUnused(pPager);
47127 static int pager_open_journal(Pager *pPager){
47129 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
47131 assert( pPager->eState==PAGER_WRITER_LOCKED );
47132 assert( assert_pager_state(pPager) );
47133 assert( pPager->pInJournal==0 );
47138 if( NEVER(pPager->errCode) ) return pPager->errCode;
47140 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
47141 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
47142 if( pPager->pInJournal==0 ){
47147 if( !isOpen(pPager->jfd) ){
47148 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
47149 sqlite3MemJournalOpen(pPager->jfd);
47153 (pPager->tempFile ?
47160 rc = databaseIsUnmoved(pPager);
47164 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
47167 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
47171 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
47180 pPager->nRec = 0;
47181 pPager->journalOff = 0;
47182 pPager->setMaster = 0;
47183 pPager->journalHdr = 0;
47184 rc = writeJournalHdr(pPager);
47189 sqlite3BitvecDestroy(pPager->pInJournal);
47190 pPager->pInJournal = 0;
47192 assert( pPager->eState==PAGER_WRITER_LOCKED );
47193 pPager->eState = PAGER_WRITER_CACHEMOD;
47216 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
47219 if( pPager->errCode ) return pPager->errCode;
47220 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
47221 pPager->subjInMemory = (u8)subjInMemory;
47223 if( ALWAYS(pPager->eState==PAGER_READER) ){
47224 assert( pPager->pInJournal==0 );
47226 if( pagerUseWal(pPager) ){
47230 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
47231 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
47235 sqlite3WalExclusiveMode(pPager->pWal, 1);
47243 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
47250 rc = pagerLockDb(pPager, RESERVED_LOCK);
47252 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
47266 pPager->eState = PAGER_WRITER_LOCKED;
47267 pPager->dbHintSize = pPager->dbSize;
47268 pPager->dbFileSize = pPager->dbSize;
47269 pPager->dbOrigSize = pPager->dbSize;
47270 pPager->journalOff = 0;
47273 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
47274 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
47275 assert( assert_pager_state(pPager) );
47278 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
47290 Pager *pPager = pPg->pPager;
47298 assert( pPager->eState==PAGER_WRITER_LOCKED
47299 || pPager->eState==PAGER_WRITER_CACHEMOD
47300 || pPager->eState==PAGER_WRITER_DBMOD
47302 assert( assert_pager_state(pPager) );
47303 assert( pPager->errCode==0 );
47304 assert( pPager->readOnly==0 );
47317 if( pPager->eState==PAGER_WRITER_LOCKED ){
47318 rc = pager_open_journal(pPager);
47321 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
47322 assert( assert_pager_state(pPager) );
47328 inJournal = pageInJournal(pPager, pPg);
47329 if( inJournal && (pPager->nSavepoint==0 || !subjRequiresPage(pPg)) ){
47330 assert( !pagerUseWal(pPager) );
47337 if( !inJournal && !pagerUseWal(pPager) ){
47338 assert( pagerUseWal(pPager)==0 );
47339 if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
47342 i64 iOff = pPager->journalOff;
47347 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
47349 assert( pPager->journalHdr<=pPager->journalOff );
47350 CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
47351 cksum = pager_cksum(pPager, (u8*)pData2);
47362 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
47364 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
47366 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
47369 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
47370 pPager->journalOff, pPager->pageSize));
47373 PAGERID(pPager), pPg->pgno,
47376 pPager->journalOff += 8 + pPager->pageSize;
47377 pPager->nRec++;
47378 assert( pPager->pInJournal!=0 );
47379 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
47382 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
47388 if( pPager->eState!=PAGER_WRITER_DBMOD ){
47392 PAGERID(pPager), pPg->pgno,
47402 if( pPager->nSavepoint>0 && subjRequiresPage(pPg) ){
47409 if( pPager->dbSize<pPg->pgno ){
47410 pPager->dbSize = pPg->pgno;
47433 Pager *pPager = pPg->pPager; /* The pager that owns pPg */
47434 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
47441 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 );
47442 pPager->doNotSpill |= SPILLFLAG_NOSYNC;
47450 nPageCount = pPager->dbSize;
47465 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
47466 if( pg!=PAGER_MJ_PGNO(pPager) ){
47467 rc = sqlite3PagerGet(pPager, pg, &pPage);
47476 }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){
47493 PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
47501 assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 );
47502 pPager->doNotSpill &= ~SPILLFLAG_NOSYNC;
47522 assert( pPg->pPager->eState>=PAGER_WRITER_LOCKED );
47523 assert( pPg->pPager->eState!=PAGER_ERROR );
47524 assert( assert_pager_state(pPg->pPager) );
47525 if( pPg->pPager->sectorSize > (u32)pPg->pPager->pageSize ){
47558 Pager *pPager = pPg->pPager;
47559 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
47560 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
47561 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
47589 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
47592 assert( pPager->eState==PAGER_WRITER_CACHEMOD
47593 || pPager->eState==PAGER_WRITER_DBMOD
47595 assert( assert_pager_state(pPager) );
47615 if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
47618 assert( !pPager->tempFile && isOpen(pPager->fd) );
47621 rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
47640 assert( pPager->dbFileSize>0 );
47641 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
47643 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
47644 pPager->aStat[PAGER_STAT_WRITE]++;
47651 memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers));
47652 pPager->changeCountDone = 1;
47655 pPager->changeCountDone = 1;
47672 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){
47675 if( isOpen(pPager->fd) ){
47677 rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
47680 if( rc==SQLITE_OK && !pPager->noSync ){
47682 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
47698 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
47700 assert( pPager->eState==PAGER_WRITER_CACHEMOD
47701 || pPager->eState==PAGER_WRITER_DBMOD
47702 || pPager->eState==PAGER_WRITER_LOCKED
47704 assert( assert_pager_state(pPager) );
47705 if( 0==pagerUseWal(pPager) ){
47706 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
47738 Pager *pPager, /* Pager object */
47744 assert( pPager->eState==PAGER_WRITER_LOCKED
47745 || pPager->eState==PAGER_WRITER_CACHEMOD
47746 || pPager->eState==PAGER_WRITER_DBMOD
47747 || pPager->eState==PAGER_ERROR
47749 assert( assert_pager_state(pPager) );
47752 if( NEVER(pPager->errCode) ) return pPager->errCode;
47755 pPager->zFilename, zMaster, pPager->dbSize));
47758 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
47765 sqlite3BackupRestart(pPager->pBackup);
47767 if( pagerUseWal(pPager) ){
47768 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
47773 rc = sqlite3PagerGet(pPager, 1, &pPageOne);
47779 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
47783 sqlite3PcacheCleanAll(pPager->pPCache);
47811 assert( isOpen(pPager->jfd)
47812 || pPager->journalMode==PAGER_JOURNALMODE_OFF
47813 || pPager->journalMode==PAGER_JOURNALMODE_WAL
47815 if( !zMaster && isOpen(pPager->jfd)
47816 && pPager->journalOff==jrnlBufferSize(pPager)
47817 && pPager->dbSize>=pPager->dbOrigSize
47818 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
47826 rc = pager_incr_changecounter(pPager, 1);
47828 rc = sqlite3JournalCreate(pPager->jfd);
47830 rc = pager_incr_changecounter(pPager, 0);
47834 rc = pager_incr_changecounter(pPager, 0);
47842 rc = writeMasterJournal(pPager, zMaster);
47856 rc = syncJournal(pPager, 0);
47859 rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
47864 sqlite3PcacheCleanAll(pPager->pPCache);
47872 if( pPager->dbSize>pPager->dbFileSize ){
47873 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
47874 assert( pPager->eState==PAGER_WRITER_DBMOD );
47875 rc = pager_truncate(pPager, nNew);
47881 rc = sqlite3PagerSync(pPager, zMaster);
47883 IOTRACE(("DBSYNC %p\n", pPager))
47888 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
47889 pPager->eState = PAGER_WRITER_FINISHED;
47910 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
47916 if( NEVER(pPager->errCode) ) return pPager->errCode;
47918 assert( pPager->eState==PAGER_WRITER_LOCKED
47919 || pPager->eState==PAGER_WRITER_FINISHED
47920 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
47922 assert( assert_pager_state(pPager) );
47935 if( pPager->eState==PAGER_WRITER_LOCKED
47936 && pPager->exclusiveMode
47937 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
47939 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
47940 pPager->eState = PAGER_READER;
47944 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
47945 pPager->iDataVersion++;
47946 rc = pager_end_transaction(pPager, pPager->setMaster, 1);
47947 return pager_error(pPager, rc);
47976 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
47978 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
47984 assert( assert_pager_state(pPager) );
47985 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
47986 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
47988 if( pagerUseWal(pPager) ){
47990 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
47991 rc2 = pager_end_transaction(pPager, pPager->setMaster, 0);
47993 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
47994 int eState = pPager->eState;
47995 rc = pager_end_transaction(pPager, 0, 0);
48001 pPager->errCode = SQLITE_ABORT;
48002 pPager->eState = PAGER_ERROR;
48006 rc = pager_playback(pPager, 0);
48009 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
48018 return pager_error(pPager, rc);
48025 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
48026 return pPager->readOnly;
48032 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
48033 return sqlite3PcacheRefCount(pPager->pPCache);
48040 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
48041 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
48043 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
48044 + sqlite3MallocSize(pPager)
48045 + pPager->pageSize;
48059 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
48061 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
48062 a[1] = sqlite3PcachePagecount(pPager->pPCache);
48063 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
48064 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
48065 a[4] = pPager->eState;
48066 a[5] = pPager->errCode;
48067 a[6] = pPager->aStat[PAGER_STAT_HIT];
48068 a[7] = pPager->aStat[PAGER_STAT_MISS];
48070 a[9] = pPager->nRead;
48071 a[10] = pPager->aStat[PAGER_STAT_WRITE];
48083 SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
48094 *pnVal += pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT];
48096 pPager->aStat[eStat - SQLITE_DBSTATUS_CACHE_HIT] = 0;
48103 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
48117 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
48119 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
48121 assert( pPager->eState>=PAGER_WRITER_LOCKED );
48122 assert( assert_pager_state(pPager) );
48124 if( nSavepoint>nCurrent && pPager->useJournal ){
48133 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
48139 pPager->aSavepoint = aNew;
48143 aNew[ii].nOrig = pPager->dbSize;
48144 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
48145 aNew[ii].iOffset = pPager->journalOff;
48147 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
48149 aNew[ii].iSubRec = pPager->nSubRec;
48150 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
48154 if( pagerUseWal(pPager) ){
48155 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
48157 pPager->nSavepoint = ii+1;
48159 assert( pPager->nSavepoint==nSavepoint );
48160 assertTruncateConstraint(pPager);
48196 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
48197 int rc = pPager->errCode; /* Return code */
48202 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
48211 for(ii=nNew; ii<pPager->nSavepoint; ii++){
48212 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
48214 pPager->nSavepoint = nNew;
48219 if( nNew==0 && isOpen(pPager->sjfd) ){
48221 if( sqlite3IsMemJournal(pPager->sjfd) ){
48222 rc = sqlite3OsTruncate(pPager->sjfd, 0);
48225 pPager->nSubRec = 0;
48233 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
48234 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
48235 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
48253 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager, int nullIfMemDb){
48254 return (nullIfMemDb && pPager->memDb) ? "" : pPager->zFilename;
48260 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
48261 return pPager->pVfs;
48269 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
48270 return pPager->fd;
48276 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
48277 return pPager->zJournal;
48284 SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
48285 return pPager->noSync;
48293 Pager *pPager,
48299 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
48300 pPager->xCodec = pPager->memDb ? 0 : xCodec;
48301 pPager->xCodecSizeChng = xCodecSizeChng;
48302 pPager->xCodecFree = xCodecFree;
48303 pPager->pCodec = pCodec;
48304 pagerReportSize(pPager);
48306 SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){
48307 return pPager->pCodec;
48319 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
48326 SQLITE_PRIVATE int sqlite3PagerState(Pager *pPager){
48327 return pPager->eState;
48357 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
48364 assert( pPager->eState==PAGER_WRITER_CACHEMOD
48365 || pPager->eState==PAGER_WRITER_DBMOD
48367 assert( assert_pager_state(pPager) );
48403 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
48404 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
48415 assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
48416 pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
48426 pPgOld = sqlite3PagerLookup(pPager, pgno);
48433 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
48469 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
48471 if( needSyncPgno<=pPager->dbOrigSize ){
48472 assert( pPager->pTmpSpace!=0 );
48473 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
48502 assert( pPg->nRef>0 || pPg->pPager->memDb );
48524 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
48530 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
48531 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
48532 pPager->exclusiveMode = (u8)eMode;
48534 return (int)pPager->exclusiveMode;
48557 SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
48558 u8 eOld = pPager->journalMode; /* Prior journalmode */
48563 print_pager_state(pPager);
48579 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
48594 assert( pPager->eState!=PAGER_ERROR );
48595 pPager->journalMode = (u8)eMode;
48608 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
48609 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
48619 sqlite3OsClose(pPager->jfd);
48620 if( pPager->eLock>=RESERVED_LOCK ){
48621 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
48624 int state = pPager->eState;
48627 rc = sqlite3PagerSharedLock(pPager);
48629 if( pPager->eState==PAGER_READER ){
48631 rc = pagerLockDb(pPager, RESERVED_LOCK);
48634 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
48637 pagerUnlockDb(pPager, SHARED_LOCK);
48639 pager_unlock(pPager);
48641 assert( state==pPager->eState );
48644 sqlite3OsClose(pPager->jfd);
48649 return (int)pPager->journalMode;
48655 SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
48656 return (int)pPager->journalMode;
48664 SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
48665 assert( assert_pager_state(pPager) );
48666 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
48667 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
48677 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
48679 pPager->journalSizeLimit = iLimit;
48680 sqlite3WalLimit(pPager->pWal, iLimit);
48682 return pPager->journalSizeLimit;
48691 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
48692 return &pPager->pBackup;
48699 SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){
48700 if( !MEMDB && pPager->tempFile==0 ) pager_reset(pPager);
48712 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
48714 if( pPager->pWal ){
48715 rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
48716 (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
48717 pPager->pBusyHandlerArg,
48718 pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
48725 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
48726 return sqlite3WalCallback(pPager->pWal);
48733 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
48734 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
48735 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
48742 static int pagerExclusiveLock(Pager *pPager){
48745 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
48746 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
48750 pagerUnlockDb(pPager, SHARED_LOCK);
48762 static int pagerOpenWal(Pager *pPager){
48765 assert( pPager->pWal==0 && pPager->tempFile==0 );
48766 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
48773 if( pPager->exclusiveMode ){
48774 rc = pagerExclusiveLock(pPager);
48781 rc = sqlite3WalOpen(pPager->pVfs,
48782 pPager->fd, pPager->zWal, pPager->exclusiveMode,
48783 pPager->journalSizeLimit, &pPager->pWal
48786 pagerFixMaplimit(pPager);
48808 Pager *pPager, /* Pager object */
48813 assert( assert_pager_state(pPager) );
48814 assert( pPager->eState==PAGER_OPEN || pbOpen );
48815 assert( pPager->eState==PAGER_READER || !pbOpen );
48817 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
48819 if( !pPager->tempFile && !pPager->pWal ){
48820 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
48823 sqlite3OsClose(pPager->jfd);
48825 rc = pagerOpenWal(pPager);
48827 pPager->journalMode = PAGER_JOURNALMODE_WAL;
48828 pPager->eState = PAGER_OPEN;
48846 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager){
48849 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
48855 if( !pPager->pWal ){
48857 rc = pagerLockDb(pPager, SHARED_LOCK);
48860 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
48864 rc = pagerOpenWal(pPager);
48871 if( rc==SQLITE_OK && pPager->pWal ){
48872 rc = pagerExclusiveLock(pPager);
48874 rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
48875 pPager->pageSize, (u8*)pPager->pTmpSpace);
48876 pPager->pWal = 0;
48877 pagerFixMaplimit(pPager);
48893 SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){
48894 assert( pPager->eState>=PAGER_READER );
48895 return sqlite3WalFramesize(pPager->pWal);
52491 Pager *pPager; /* The page cache */
52746 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
53931 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
53974 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
54277 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
54806 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
54820 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
55042 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0))
55043 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
55092 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
55095 sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
55096 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
55103 sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
55108 if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
55143 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
55206 if( pBt && pBt->pPager ){
55207 sqlite3PagerClose(pBt->pPager);
55218 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
55348 sqlite3PagerClose(pBt->pPager);
55387 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
55401 sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
55423 sqlite3PagerSetFlags(pBt->pPager, pgFlags);
55438 assert( pBt && pBt->pPager );
55439 rc = sqlite3PagerNosync(pBt->pPager);
55487 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
55548 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
55636 rc = sqlite3PagerSharedLock(pBt->pPager);
55645 sqlite3PagerPagecount(pBt->pPager, &nPageFile);
55686 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
55738 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
55831 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
56000 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
56060 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
56195 Pager *pPager = pBt->pPager;
56206 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
56444 Pager *pPager = pBt->pPager;
56445 VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
56483 sqlite3PagerRollback(pPager);
56487 assert( nRef>=sqlite3PagerRefcount(pPager) );
56535 sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
56538 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
56624 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
56747 rc2 = sqlite3PagerRollback(pBt->pPager);
56758 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
56805 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
56829 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
57394 && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (3) */
57410 rc = sqlite3PagerAcquire(pBt->pPager, nextPage, &pDbPage,
59205 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
59370 u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
61282 *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
61406 return p->pBt->pPager;
61535 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
61929 nRef = sqlite3PagerRefcount(pBt->pPager);
61931 sCheck.pPager = pBt->pPager;
62002 if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
62005 nRef, sqlite3PagerRefcount(pBt->pPager)
62032 assert( p->pBt->pPager!=0 );
62033 return sqlite3PagerFilename(p->pBt->pPager, 1);
62045 assert( p->pBt->pPager!=0 );
62046 return sqlite3PagerJournalname(p->pBt->pPager);
62074 rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
76665 Pager *pPager; /* Pager associated with pBt */
76686 pPager = sqlite3BtreePager(pBt);
76687 eOld = sqlite3PagerGetJournalMode(pPager);
76689 if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
76692 zFilename = sqlite3PagerFilename(pPager, 1);
76699 || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
76722 rc = sqlite3PagerCloseWal(pPager);
76724 sqlite3PagerSetJournalMode(pPager, eNew);
76729 sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
76746 eNew = sqlite3PagerSetJournalMode(pPager, eNew);
90099 Pager *pPager;
90109 pPager = sqlite3BtreePager(aNew->pBt);
90110 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
104128 Pager *pPager;
104141 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
104142 sqlite3PagerLockingMode(pPager, eMode);
104146 pPager = sqlite3BtreePager(pDb->pBt);
104147 eMode = sqlite3PagerLockingMode(pPager, eMode);
104212 Pager *pPager = sqlite3BtreePager(pDb->pBt);
104218 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
104489 Pager *pPager = sqlite3BtreePager(pDb->pBt);
104491 sqlite3_file *pFile = sqlite3PagerFile(pPager);
104503 Pager *pPager = sqlite3BtreePager(pDb->pBt);
104504 sqlite3_file *pFile = sqlite3PagerFile(pPager);
128717 Pager *pPager = sqlite3BtreePager(pBt);
128718 sqlite3PagerShrink(pPager);
131322 Pager *pPager;
131325 pPager = sqlite3BtreePager(pBtree);
131326 assert( pPager!=0 );
131327 fd = sqlite3PagerFile(pPager);
155617 Pager *pPager = sqlite3BtreePager(pBt);
155628 fd = sqlite3PagerFile(pPager);
155646 Pager *pPager = sqlite3BtreePager(pBt);
155657 sqlite3PagerPagecount(pPager, &nPage);
155662 rc = sqlite3PagerGet(pPager, iRoot, &pCsr->aPage[0].pPg);
155722 rc = sqlite3PagerGet(pPager, p[1].iPgno, &p[1].pPg);
