Lines Matching refs:pPager
7878 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
7895 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
7897 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
7914 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
7917 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
7918 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
7919 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
7921 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager);
7922 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
7923 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
7924 SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
7925 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);
7996 Pager *pPager; /* The pager this page is part of */
12160 Pager *pPager = sqlite3BtreePager(pBt);
12161 totalUsed += sqlite3PagerMemUsed(pPager);
34872 ** the page number and the pPager->pageSize bytes of data for the page.
34889 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
34895 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
34906 # define MEMDB pPager->memDb
34920 ** if( isOpen(pPager->jfd) ){ ...
34924 ** if( pPager->jfd->pMethods ){ ...
34933 static int pagerUseWal(Pager *pPager){
34934 return (pPager->pWal!=0);
34948 ** assert( assert_pager_state(pPager) );
34954 Pager *pPager = p;
34971 assert( p->tempFile==0 || pPager->changeCountDone );
34999 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
35005 assert( pPager->errCode==SQLITE_OK );
35006 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
35010 assert( pPager->errCode==SQLITE_OK );
35017 assert( pPager->errCode==SQLITE_OK );
35018 if( !pagerUseWal(pPager) ){
35021 assert( pPager->dbSize==pPager->dbOrigSize );
35022 assert( pPager->dbOrigSize==pPager->dbFileSize );
35023 assert( pPager->dbOrigSize==pPager->dbHintSize );
35024 assert( pPager->setMaster==0 );
35029 assert( pPager->errCode==SQLITE_OK );
35030 if( !pagerUseWal(pPager) ){
35042 assert( pPager->dbOrigSize==pPager->dbFileSize );
35043 assert( pPager->dbOrigSize==pPager->dbHintSize );
35048 assert( pPager->errCode==SQLITE_OK );
35049 assert( !pagerUseWal(pPager) );
35055 assert( pPager->dbOrigSize<=pPager->dbHintSize );
35060 assert( pPager->errCode==SQLITE_OK );
35061 assert( !pagerUseWal(pPager) );
35073 assert( pPager->errCode!=SQLITE_OK );
35074 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
35085 ** to "print *pPager" in gdb:
35087 ** (gdb) printf "%s", print_pager_state(pPager)
35142 Pager *pPager = pPg->pPager;
35144 for(i=0; i<pPager->nSavepoint; i++){
35145 PagerSavepoint *p = &pPager->aSavepoint[i];
35157 return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
35201 static int pagerUnlockDb(Pager *pPager, int eLock){
35204 assert( !pPager->exclusiveMode );
35206 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
35207 if( isOpen(pPager->fd) ){
35208 assert( pPager->eLock>=eLock );
35209 rc = sqlite3OsUnlock(pPager->fd, eLock);
35210 if( pPager->eLock!=UNKNOWN_LOCK ){
35211 pPager->eLock = (u8)eLock;
35213 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
35228 static int pagerLockDb(Pager *pPager, int eLock){
35232 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
35233 rc = sqlite3OsLock(pPager->fd, eLock);
35234 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
35235 pPager->eLock = (u8)eLock;
35236 IOTRACE(("LOCK %p %d\n", pPager, eLock))
35252 ** an error to call this function if pPager is opened on an in-memory
35260 static int jrnlBufferSize(Pager *pPager){
35262 if( !pPager->tempFile ){
35267 assert( isOpen(pPager->fd) );
35268 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
35269 nSector = pPager->sectorSize;
35270 szPage = pPager->pageSize;
35279 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
35301 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
35314 Pager *pPager = pPg->pPager;
35315 assert( pPager->eState!=PAGER_ERROR );
35327 ** When this is called the journal file for pager pPager must be open.
35391 ** following the value in pPager->journalOff, assuming a sector
35392 ** size of pPager->sectorSize bytes.
35404 static i64 journalHdrOffset(Pager *pPager){
35406 i64 c = pPager->journalOff;
35408 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
35410 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
35412 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
35437 static int zeroJournalHdr(Pager *pPager, int doTruncate){
35439 assert( isOpen(pPager->jfd) );
35440 if( pPager->journalOff ){
35441 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
35443 IOTRACE(("JZEROHDR %p\n", pPager))
35445 rc = sqlite3OsTruncate(pPager->jfd, 0);
35448 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
35450 if( rc==SQLITE_OK && !pPager->noSync ){
35451 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->sync_flags);
35462 rc = sqlite3OsFileSize(pPager->jfd, &sz);
35464 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
35486 static int writeJournalHdr(Pager *pPager){
35488 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
35489 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
35493 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
35495 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
35496 nHeader = JOURNAL_HDR_SZ(pPager);
35503 for(ii=0; ii<pPager->nSavepoint; ii++){
35504 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
35505 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
35509 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
35531 assert( isOpen(pPager->fd) || pPager->noSync );
35532 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
35533 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
35542 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
35543 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
35545 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
35547 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
35550 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
35577 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
35578 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
35579 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
35580 assert( pPager->journalHdr <= pPager->journalOff );
35581 pPager->journalOff += nHeader;
35591 ** pPager->journalOff. See comments above function writeJournalHdr() for
35596 ** database before the transaction began, in pages. Also, pPager->cksumInit
35605 Pager *pPager, /* Pager object */
35615 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
35621 pPager->journalOff = journalHdrOffset(pPager);
35622 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
35625 iHdrOff = pPager->journalOff;
35632 if( isHot || iHdrOff!=pPager->journalHdr ){
35633 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
35646 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
35647 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
35648 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
35653 if( pPager->journalOff==0 ){
35658 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
35659 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
35669 iPageSize = pPager->pageSize;
35693 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
35702 pPager->sectorSize = iSectorSize;
35705 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
35712 ** pPager at the current location. The master journal name must be the last
35729 static int writeMasterJournal(Pager *pPager, const char *zMaster){
35736 assert( pPager->setMaster==0 );
35737 assert( !pagerUseWal(pPager) );
35740 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
35741 || pPager->journalMode==PAGER_JOURNALMODE_OFF
35745 pPager->setMaster = 1;
35746 assert( isOpen(pPager->jfd) );
35747 assert( pPager->journalHdr <= pPager->journalOff );
35758 if( pPager->fullSync ){
35759 pPager->journalOff = journalHdrOffset(pPager);
35761 iHdrOff = pPager->journalOff;
35766 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
35767 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
35768 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
35769 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
35770 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
35774 pPager->journalOff += (nMaster+20);
35786 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
35787 && jrnlSize>pPager->journalOff
35789 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
35799 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
35805 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
35812 static void pager_reset(Pager *pPager){
35813 sqlite3BackupRestart(pPager->pBackup);
35814 sqlite3PcacheClear(pPager->pPCache);
35822 static void releaseAllSavepoints(Pager *pPager){
35824 for(ii=0; ii<pPager->nSavepoint; ii++){
35825 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
35827 if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
35828 sqlite3OsClose(pPager->sjfd);
35830 sqlite3_free(pPager->aSavepoint);
35831 pPager->aSavepoint = 0;
35832 pPager->nSavepoint = 0;
35833 pPager->nSubRec = 0;
35841 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
35845 for(ii=0; ii<pPager->nSavepoint; ii++){
35846 PagerSavepoint *p = &pPager->aSavepoint[ii];
35873 static void pager_unlock(Pager *pPager){
35875 assert( pPager->eState==PAGER_READER
35876 || pPager->eState==PAGER_OPEN
35877 || pPager->eState==PAGER_ERROR
35880 sqlite3BitvecDestroy(pPager->pInJournal);
35881 pPager->pInJournal = 0;
35882 releaseAllSavepoints(pPager);
35884 if( pagerUseWal(pPager) ){
35885 assert( !isOpen(pPager->jfd) );
35886 sqlite3WalEndReadTransaction(pPager->pWal);
35887 pPager->eState = PAGER_OPEN;
35888 }else if( !pPager->exclusiveMode ){
35890 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
35904 || 1!=(pPager->journalMode & 5)
35906 sqlite3OsClose(pPager->jfd);
35914 rc = pagerUnlockDb(pPager, NO_LOCK);
35915 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
35916 pPager->eLock = UNKNOWN_LOCK;
35923 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
35924 pPager->changeCountDone = 0;
35925 pPager->eState = PAGER_OPEN;
35933 if( pPager->errCode ){
35935 pager_reset(pPager);
35936 pPager->changeCountDone = pPager->tempFile;
35937 pPager->eState = PAGER_OPEN;
35938 pPager->errCode = SQLITE_OK;
35941 pPager->journalOff = 0;
35942 pPager->journalHdr = 0;
35943 pPager->setMaster = 0;
35965 static int pager_error(Pager *pPager, int rc){
35969 pPager->errCode==SQLITE_FULL ||
35970 pPager->errCode==SQLITE_OK ||
35971 (pPager->errCode & 0xff)==SQLITE_IOERR
35974 pPager->errCode = rc;
35975 pPager->eState = PAGER_ERROR;
36033 static int pager_end_transaction(Pager *pPager, int hasMaster){
36050 assert( assert_pager_state(pPager) );
36051 assert( pPager->eState!=PAGER_ERROR );
36052 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
36056 releaseAllSavepoints(pPager);
36057 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
36058 if( isOpen(pPager->jfd) ){
36059 assert( !pagerUseWal(pPager) );
36062 if( sqlite3IsMemJournal(pPager->jfd) ){
36063 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
36064 sqlite3OsClose(pPager->jfd);
36065 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
36066 if( pPager->journalOff==0 ){
36069 rc = sqlite3OsTruncate(pPager->jfd, 0);
36071 pPager->journalOff = 0;
36072 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
36073 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
36075 rc = zeroJournalHdr(pPager, hasMaster);
36076 pPager->journalOff = 0;
36083 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
36084 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
36085 || pPager->journalMode==PAGER_JOURNALMODE_WAL
36087 sqlite3OsClose(pPager->jfd);
36088 if( !pPager->tempFile ){
36089 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
36095 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
36096 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
36097 PgHdr *p = pager_lookup(pPager, 1);
36105 sqlite3BitvecDestroy(pPager->pInJournal);
36106 pPager->pInJournal = 0;
36107 pPager->nRec = 0;
36108 sqlite3PcacheCleanAll(pPager->pPCache);
36109 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
36111 if( pagerUseWal(pPager) ){
36116 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
36119 if( !pPager->exclusiveMode
36120 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
36122 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
36123 pPager->changeCountDone = 0;
36125 pPager->eState = PAGER_READER;
36126 pPager->setMaster = 0;
36148 static void pagerUnlockAndRollback(Pager *pPager){
36149 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
36150 assert( assert_pager_state(pPager) );
36151 if( pPager->eState>=PAGER_WRITER_LOCKED ){
36153 sqlite3PagerRollback(pPager);
36155 }else if( !pPager->exclusiveMode ){
36156 assert( pPager->eState==PAGER_READER );
36157 pager_end_transaction(pPager, 0);
36160 pager_unlock(pPager);
36164 ** Parameter aData must point to a buffer of pPager->pageSize bytes
36166 ** page of data and the current value of pPager->cksumInit.
36169 ** random initial value (pPager->cksumInit) and every 200th byte
36170 ** of the page data, starting with byte offset (pPager->pageSize%200).
36182 static u32 pager_cksum(Pager *pPager, const u8 *aData){
36183 u32 cksum = pPager->cksumInit; /* Checksum value to return */
36184 int i = pPager->pageSize-200; /* Loop counter */
36197 static void pagerReportSize(Pager *pPager){
36198 if( pPager->xCodecSizeChng ){
36199 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
36200 (int)pPager->nReserve);
36245 Pager *pPager, /* The pager being played back */
36264 aData = pPager->pTmpSpace;
36266 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
36274 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
36275 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
36277 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
36282 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
36285 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
36287 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
36294 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
36298 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
36304 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
36318 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
36319 pPager->nReserve = ((u8*)aData)[20];
36320 pagerReportSize(pPager);
36358 if( pagerUseWal(pPager) ){
36361 pPg = pager_lookup(pPager, pgno);
36364 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
36366 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
36370 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
36374 if( isOpen(pPager->fd)
36375 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
36378 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
36380 assert( !pagerUseWal(pPager) );
36381 rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
36382 if( pgno>pPager->dbFileSize ){
36383 pPager->dbFileSize = pgno;
36385 if( pPager->pBackup ){
36386 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
36387 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
36388 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
36408 assert( pPager->doNotSpill==0 );
36409 pPager->doNotSpill++;
36410 rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
36411 assert( pPager->doNotSpill==1 );
36412 pPager->doNotSpill--;
36426 memcpy(pData, (u8*)aData, pPager->pageSize);
36427 pPager->xReiniter(pPg);
36428 if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
36448 assert( !pagerUseWal(pPager) );
36456 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
36460 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
36509 static int pager_delmaster(Pager *pPager, const char *zMaster){
36510 sqlite3_vfs *pVfs = pPager->pVfs;
36606 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
36619 static int pager_truncate(Pager *pPager, Pgno nPage){
36621 assert( pPager->eState!=PAGER_ERROR );
36622 assert( pPager->eState!=PAGER_READER );
36624 if( isOpen(pPager->fd)
36625 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
36628 assert( pPager->eLock==EXCLUSIVE_LOCK );
36630 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
36631 newSize = pPager->pageSize*(i64)nPage;
36634 rc = sqlite3OsTruncate(pPager->fd, newSize);
36636 rc = sqlite3OsWrite(pPager->fd, "", 1, newSize-1);
36639 pPager->dbFileSize = nPage;
36660 static void setSectorSize(Pager *pPager){
36661 assert( isOpen(pPager->fd) || pPager->tempFile );
36663 if( !pPager->tempFile ){
36668 pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
36670 if( pPager->sectorSize<32 ){
36671 pPager->sectorSize = 512;
36673 if( pPager->sectorSize>MAX_SECTOR_SIZE ){
36675 pPager->sectorSize = MAX_SECTOR_SIZE;
36699 ** + pPager->pageSize bytes of data.
36736 static int pager_playback(Pager *pPager, int isHot){
36737 sqlite3_vfs *pVfs = pPager->pVfs;
36750 assert( isOpen(pPager->jfd) );
36751 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
36763 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
36767 zMaster = pPager->pTmpSpace;
36768 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
36776 pPager->journalOff = 0;
36789 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
36803 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
36804 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
36822 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
36823 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
36829 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
36830 rc = pager_truncate(pPager, mxPg);
36834 pPager->dbSize = mxPg;
36842 pager_reset(pPager);
36845 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
36849 pPager->journalOff = szJ;
36880 pPager->fd->pMethods==0 ||
36881 sqlite3OsFileControl(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0)>=SQLITE_OK
36893 pPager->changeCountDone = pPager->tempFile;
36896 zMaster = pPager->pTmpSpace;
36897 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
36900 if( rc==SQLITE_OK && !pPager->noSync
36901 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
36903 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
36906 rc = pager_end_transaction(pPager, zMaster[0]!='\0');
36913 rc = pager_delmaster(pPager, zMaster);
36921 setSectorSize(pPager);
36938 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
36942 int pgsz = pPager->pageSize; /* Number of bytes to read */
36944 assert( pPager->eState>=PAGER_READER && !MEMDB );
36945 assert( isOpen(pPager->fd) );
36947 if( NEVER(!isOpen(pPager->fd)) ){
36948 assert( pPager->tempFile );
36949 memset(pPg->pData, 0, pPager->pageSize);
36953 if( pagerUseWal(pPager) ){
36955 rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
36958 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
36959 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
36972 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
36979 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
36982 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
36985 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
36988 PAGER_INCR(pPager->nRead);
36989 IOTRACE(("PGIN %p %d\n", pPager, pgno));
36991 PAGERID(pPager), pgno, pager_pagehash(pPg)));
37011 Pager *pPager = (Pager *)pCtx;
37014 pPg = sqlite3PagerLookup(pPager, iPg);
37021 pPager->xReiniter(pPg);
37035 sqlite3BackupRestart(pPager->pBackup);
37043 static int pagerRollbackWal(Pager *pPager){
37054 pPager->dbSize = pPager->dbOrigSize;
37055 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
37056 pList = sqlite3PcacheDirtyList(pPager->pPCache);
37059 rc = pagerUndoCallback((void *)pPager, pList->pgno);
37073 Pager *pPager, /* Pager object */
37081 assert( pPager->pWal );
37082 rc = sqlite3WalFrames(pPager->pWal,
37083 pPager->pageSize, pList, nTruncate, isCommit, sync_flags
37085 if( rc==SQLITE_OK && pPager->pBackup ){
37088 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
37110 static int pagerBeginReadTransaction(Pager *pPager){
37114 assert( pagerUseWal(pPager) );
37115 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
37122 sqlite3WalEndReadTransaction(pPager->pWal);
37124 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
37126 pager_reset(pPager);
37141 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
37150 assert( pPager->eState==PAGER_OPEN );
37151 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
37152 nPage = sqlite3WalDbsize(pPager->pWal);
37162 assert( isOpen(pPager->fd) || pPager->tempFile );
37163 if( isOpen(pPager->fd) ){
37164 int rc = sqlite3OsFileSize(pPager->fd, &n);
37169 nPage = (Pgno)(n / pPager->pageSize);
37179 if( nPage>pPager->mxPgno ){
37180 pPager->mxPgno = (Pgno)nPage;
37189 ** Check if the *-wal file that corresponds to the database opened by pPager
37206 static int pagerOpenWalIfPresent(Pager *pPager){
37208 assert( pPager->eState==PAGER_OPEN );
37209 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
37211 if( !pPager->tempFile ){
37215 rc = pagerPagecount(pPager, &nPage);
37218 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
37222 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
37227 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
37228 rc = sqlite3PagerOpenWal(pPager, 0);
37229 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
37230 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
37274 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
37280 assert( pPager->eState!=PAGER_ERROR );
37281 assert( pPager->eState>=PAGER_WRITER_LOCKED );
37294 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
37295 pPager->changeCountDone = pPager->tempFile;
37297 if( !pSavepoint && pagerUseWal(pPager) ){
37298 return pagerRollbackWal(pPager);
37301 /* Use pPager->journalOff as the effective size of the main rollback
37304 ** past pPager->journalOff is off-limits to us.
37306 szJ = pPager->journalOff;
37307 assert( pagerUseWal(pPager)==0 || szJ==0 );
37312 ** greater than the current database size (pPager->dbSize) but those
37316 if( pSavepoint && !pagerUseWal(pPager) ){
37318 pPager->journalOff = pSavepoint->iOffset;
37319 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
37320 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
37324 pPager->journalOff = 0;
37332 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
37336 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
37340 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
37345 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
37347 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
37349 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
37350 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
37354 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
37362 i64 offset = pSavepoint->iSubRec*(4+pPager->pageSize);
37364 if( pagerUseWal(pPager) ){
37365 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
37367 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
37368 assert( offset==ii*(4+pPager->pageSize) );
37369 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
37376 pPager->journalOff = szJ;
37385 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
37386 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
37416 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
37417 pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
37418 pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
37419 pPager->sync_flags = (bFullFsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
37448 Pager *pPager, /* The pager object */
37460 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
37487 Pager *pPager, /* Pager object */
37491 pPager->xBusyHandler = xBusyHandler;
37492 pPager->pBusyHandlerArg = pBusyHandlerArg;
37525 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
37540 if( (pPager->memDb==0 || pPager->dbSize==0)
37541 && sqlite3PcacheRefCount(pPager->pPCache)==0
37542 && pageSize && pageSize!=(u32)pPager->pageSize
37547 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
37548 rc = sqlite3OsFileSize(pPager->fd, &nByte);
37556 pager_reset(pPager);
37557 pPager->dbSize = (Pgno)(nByte/pageSize);
37558 pPager->pageSize = pageSize;
37559 sqlite3PageFree(pPager->pTmpSpace);
37560 pPager->pTmpSpace = pNew;
37561 sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
37565 *pPageSize = pPager->pageSize;
37567 if( nReserve<0 ) nReserve = pPager->nReserve;
37569 pPager->nReserve = (i16)nReserve;
37570 pagerReportSize(pPager);
37583 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
37584 return pPager->pTmpSpace;
37594 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
37596 pPager->mxPgno = mxPage;
37598 if( pPager->eState!=PAGER_OPEN && pPager->mxPgno<pPager->dbSize ){
37599 pPager->mxPgno = pPager->dbSize;
37601 return pPager->mxPgno;
37642 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
37645 assert( isOpen(pPager->fd) || pPager->tempFile );
37651 assert( !pagerUseWal(pPager) );
37653 if( isOpen(pPager->fd) ){
37654 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
37655 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
37670 SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
37671 assert( pPager->eState>=PAGER_READER );
37672 assert( pPager->eState!=PAGER_WRITER_FINISHED );
37673 *pnPage = (int)pPager->dbSize;
37691 static int pager_wait_on_lock(Pager *pPager, int locktype){
37699 assert( (pPager->eLock>=locktype)
37700 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
37701 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
37705 rc = pagerLockDb(pPager, locktype);
37706 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
37711 ** Function assertTruncateConstraint(pPager) checks that one of the
37735 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
37737 static void assertTruncateConstraint(Pager *pPager){
37738 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
37741 # define assertTruncateConstraint(pPager)
37750 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
37751 assert( pPager->dbSize>=nPage );
37752 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
37753 pPager->dbSize = nPage;
37754 assertTruncateConstraint(pPager);
37760 ** syncs the journal file to disk, then sets pPager->journalHdr to the
37772 static int pagerSyncHotJournal(Pager *pPager){
37774 if( !pPager->noSync ){
37775 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
37778 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
37797 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
37798 u8 *pTmp = (u8 *)pPager->pTmpSpace;
37802 /* pPager->errCode = 0; */
37803 pPager->exclusiveMode = 0;
37805 sqlite3WalClose(pPager->pWal,
37806 (pPager->noSync ? 0 : pPager->sync_flags),
37807 pPager->pageSize, pTmp
37809 pPager->pWal = 0;
37811 pager_reset(pPager);
37813 pager_unlock(pPager);
37826 if( isOpen(pPager->jfd) ){
37827 pager_error(pPager, pagerSyncHotJournal(pPager));
37829 pagerUnlockAndRollback(pPager);
37833 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
37834 IOTRACE(("CLOSE %p\n", pPager))
37835 sqlite3OsClose(pPager->jfd);
37836 sqlite3OsClose(pPager->fd);
37838 sqlite3PcacheClose(pPager->pPCache);
37841 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
37844 assert( !pPager->aSavepoint && !pPager->pInJournal );
37845 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
37847 sqlite3_free(pPager);
37902 static int syncJournal(Pager *pPager, int newHdr){
37905 assert( pPager->eState==PAGER_WRITER_CACHEMOD
37906 || pPager->eState==PAGER_WRITER_DBMOD
37908 assert( assert_pager_state(pPager) );
37909 assert( !pagerUseWal(pPager) );
37911 rc = sqlite3PagerExclusiveLock(pPager);
37914 if( !pPager->noSync ){
37915 assert( !pPager->tempFile );
37916 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
37917 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
37918 assert( isOpen(pPager->jfd) );
37948 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
37950 iNextHdrOffset = journalHdrOffset(pPager);
37951 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
37954 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
37971 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
37972 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
37973 IOTRACE(("JSYNC %p\n", pPager))
37974 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
37977 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
37979 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
37984 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
37985 IOTRACE(("JSYNC %p\n", pPager))
37986 rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags|
37987 (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
37992 pPager->journalHdr = pPager->journalOff;
37994 pPager->nRec = 0;
37995 rc = writeJournalHdr(pPager);
37999 pPager->journalHdr = pPager->journalOff;
38007 sqlite3PcacheClearSyncFlags(pPager->pPCache);
38008 pPager->eState = PAGER_WRITER_DBMOD;
38009 assert( assert_pager_state(pPager) );
38045 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
38049 assert( !pagerUseWal(pPager) );
38050 assert( pPager->eState==PAGER_WRITER_DBMOD );
38051 assert( pPager->eLock==EXCLUSIVE_LOCK );
38057 if( !isOpen(pPager->fd) ){
38058 assert( pPager->tempFile && rc==SQLITE_OK );
38059 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
38065 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
38066 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbHintSize ){
38067 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
38068 sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
38069 pPager->dbHintSize = pPager->dbSize;
38083 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
38084 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
38090 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
38093 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
38100 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
38102 if( pgno>pPager->dbFileSize ){
38103 pPager->dbFileSize = pgno;
38107 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
38110 PAGERID(pPager), pgno, pager_pagehash(pList)));
38111 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
38113 PAGER_INCR(pPager->nWrite);
38115 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
38132 static int openSubJournal(Pager *pPager){
38134 if( !isOpen(pPager->sjfd) ){
38135 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
38136 sqlite3MemJournalOpen(pPager->sjfd);
38138 rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
38159 Pager *pPager = pPg->pPager;
38160 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
38163 assert( pPager->useJournal );
38164 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
38165 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
38166 assert( pagerUseWal(pPager)
38168 || pPg->pgno>pPager->dbOrigSize
38170 rc = openSubJournal(pPager);
38176 i64 offset = pPager->nSubRec*(4+pPager->pageSize);
38179 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
38180 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
38181 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
38183 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
38188 pPager->nSubRec++;
38189 assert( pPager->nSavepoint>0 );
38190 rc = addToSavepointBitvecs(pPager, pPg->pgno);
38215 Pager *pPager = (Pager *)p;
38218 assert( pPg->pPager==pPager );
38236 if( NEVER(pPager->errCode) ) return SQLITE_OK;
38237 if( pPager->doNotSpill ) return SQLITE_OK;
38238 if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
38243 if( pagerUseWal(pPager) ){
38249 rc = pagerWalFrames(pPager, pPg, 0, 0, 0);
38255 || pPager->eState==PAGER_WRITER_CACHEMOD
38257 rc = syncJournal(pPager, 1);
38288 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
38296 rc = pager_write_pagelist(pPager, pPg);
38302 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
38306 return pager_error(pPager, rc);
38350 Pager *pPager = 0; /* Pager object to allocate and return */
38430 ROUND8(sizeof(*pPager)) + /* Pager structure */
38445 pPager = (Pager*)(pPtr);
38446 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
38447 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
38448 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
38449 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
38450 pPager->zFilename = (char*)(pPtr += journalFileSize);
38451 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
38455 pPager->zJournal = (char*)(pPtr += nPathname + 1);
38456 memcpy(pPager->zFilename, zPathname, nPathname);
38457 memcpy(pPager->zJournal, zPathname, nPathname);
38458 memcpy(&pPager->zJournal[nPathname], "-journal", 8);
38459 if( pPager->zFilename[0]==0 ){
38460 pPager->zJournal[0] = 0;
38464 pPager->zWal = &pPager->zJournal[nPathname+8+1];
38465 memcpy(pPager->zWal, zPathname, nPathname);
38466 memcpy(&pPager->zWal[nPathname], "-wal", 4);
38471 pPager->pVfs = pVfs;
38472 pPager->vfsFlags = vfsFlags;
38478 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
38490 setSectorSize(pPager);
38492 if( szPageDflt<pPager->sectorSize ){
38493 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
38496 szPageDflt = (u32)pPager->sectorSize;
38501 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
38524 pPager->eState = PAGER_READER;
38525 pPager->eLock = EXCLUSIVE_LOCK;
38533 assert( pPager->memDb==0 );
38534 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
38542 assert( !pPager->pTmpSpace );
38543 sqlite3OsClose(pPager->fd);
38544 sqlite3_free(pPager);
38552 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
38554 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
38555 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
38557 pPager->useJournal = (u8)useJournal;
38558 pPager->noReadlock = (noReadlock && readOnly) ?1:0;
38559 /* pPager->stmtOpen = 0; */
38560 /* pPager->stmtInUse = 0; */
38561 /* pPager->nRef = 0; */
38562 /* pPager->stmtSize = 0; */
38563 /* pPager->stmtJSize = 0; */
38564 /* pPager->nPage = 0; */
38565 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
38566 /* pPager->state = PAGER_UNLOCK; */
38568 assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
38570 /* pPager->errMask = 0; */
38571 pPager->tempFile = (u8)tempFile;
38575 pPager->exclusiveMode = (u8)tempFile;
38576 pPager->changeCountDone = pPager->tempFile;
38577 pPager->memDb = (u8)memDb;
38578 pPager->readOnly = (u8)readOnly;
38579 assert( useJournal || pPager->tempFile );
38580 pPager->noSync = pPager->tempFile;
38581 pPager->fullSync = pPager->noSync ?0:1;
38582 pPager->sync_flags = SQLITE_SYNC_NORMAL;
38583 /* pPager->pFirst = 0; */
38584 /* pPager->pFirstSynced = 0; */
38585 /* pPager->pLast = 0; */
38586 pPager->nExtra = (u16)nExtra;
38587 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
38588 assert( isOpen(pPager->fd) || tempFile );
38589 setSectorSize(pPager);
38591 pPager->journalMode = PAGER_JOURNALMODE_OFF;
38593 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
38595 /* pPager->xBusyHandler = 0; */
38596 /* pPager->pBusyHandlerArg = 0; */
38597 pPager->xReiniter = xReinit;
38598 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
38600 *ppPager = pPager;
38637 static int hasHotJournal(Pager *pPager, int *pExists){
38638 sqlite3_vfs * const pVfs = pPager->pVfs;
38641 int jrnlOpen = !!isOpen(pPager->jfd);
38643 assert( pPager->useJournal );
38644 assert( isOpen(pPager->fd) );
38645 assert( pPager->eState==PAGER_OPEN );
38647 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
38653 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
38666 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
38676 rc = pagerPagecount(pPager, &nPage);
38680 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
38681 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
38682 pagerUnlockDb(pPager, SHARED_LOCK);
38694 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
38698 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
38703 sqlite3OsClose(pPager->jfd);
38754 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
38762 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
38763 assert( assert_pager_state(pPager) );
38764 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
38765 if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
38767 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
38771 assert( pPager->noReadlock==0 || pPager->readOnly );
38773 if( pPager->noReadlock==0 ){
38774 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
38776 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
38784 if( pPager->eLock<=SHARED_LOCK ){
38785 rc = hasHotJournal(pPager, &bHotJournal);
38806 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
38824 if( !isOpen(pPager->jfd) ){
38825 sqlite3_vfs * const pVfs = pPager->pVfs;
38828 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
38832 assert( !pPager->tempFile );
38833 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
38834 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
38837 sqlite3OsClose(pPager->jfd);
38850 if( isOpen(pPager->jfd) ){
38852 rc = pagerSyncHotJournal(pPager);
38854 rc = pager_playback(pPager, 1);
38855 pPager->eState = PAGER_OPEN;
38857 }else if( !pPager->exclusiveMode ){
38858 pagerUnlockDb(pPager, SHARED_LOCK);
38878 pager_error(pPager, rc);
38882 assert( pPager->eState==PAGER_OPEN );
38883 assert( (pPager->eLock==SHARED_LOCK)
38884 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
38888 if( !pPager->tempFile
38889 && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0)
38908 char dbFileVers[sizeof(pPager->dbFileVers)];
38910 rc = pagerPagecount(pPager, &nPage);
38914 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
38915 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
38923 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
38924 pager_reset(pPager);
38931 rc = pagerOpenWalIfPresent(pPager);
38932 assert( pPager->pWal==0 || rc==SQLITE_OK );
38935 if( pagerUseWal(pPager) ){
38937 rc = pagerBeginReadTransaction(pPager);
38940 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
38941 rc = pagerPagecount(pPager, &pPager->dbSize);
38947 pager_unlock(pPager);
38948 assert( pPager->eState==PAGER_OPEN );
38950 pPager->eState = PAGER_READER;
38963 static void pagerUnlockIfUnused(Pager *pPager){
38964 if( (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
38965 pagerUnlockAndRollback(pPager);
38970 ** Acquire a reference to page number pgno in pager pPager (a page
39020 Pager *pPager, /* The pager open on the database file */
39028 assert( pPager->eState>=PAGER_READER );
39029 assert( assert_pager_state(pPager) );
39037 if( pPager->errCode!=SQLITE_OK ){
39038 rc = pPager->errCode;
39040 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
39051 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
39053 if( (*ppPage)->pPager && !noContent ){
39056 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
39057 PAGER_INCR(pPager->nHit);
39064 PAGER_INCR(pPager->nMiss);
39066 pPg->pPager = pPager;
39070 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
39075 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
39076 if( pgno>pPager->mxPgno ){
39088 if( pgno<=pPager->dbOrigSize ){
39089 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
39092 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
39096 memset(pPg->pData, 0, pPager->pageSize);
39097 IOTRACE(("ZERO %p %d\n", pPager, pgno));
39099 assert( pPg->pPager==pPager );
39115 pagerUnlockIfUnused(pPager);
39132 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
39134 assert( pPager!=0 );
39136 assert( pPager->pPCache!=0 );
39137 assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
39138 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
39152 Pager *pPager = pPg->pPager;
39154 pagerUnlockIfUnused(pPager);
39163 ** Open the journal file for pager pPager and write a journal header
39180 static int pager_open_journal(Pager *pPager){
39182 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
39184 assert( pPager->eState==PAGER_WRITER_LOCKED );
39185 assert( assert_pager_state(pPager) );
39186 assert( pPager->pInJournal==0 );
39191 if( NEVER(pPager->errCode) ) return pPager->errCode;
39193 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
39194 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
39195 if( pPager->pInJournal==0 ){
39200 if( !isOpen(pPager->jfd) ){
39201 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
39202 sqlite3MemJournalOpen(pPager->jfd);
39206 (pPager->tempFile ?
39212 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
39215 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
39218 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
39227 pPager->nRec = 0;
39228 pPager->journalOff = 0;
39229 pPager->setMaster = 0;
39230 pPager->journalHdr = 0;
39231 rc = writeJournalHdr(pPager);
39236 sqlite3BitvecDestroy(pPager->pInJournal);
39237 pPager->pInJournal = 0;
39239 assert( pPager->eState==PAGER_WRITER_LOCKED );
39240 pPager->eState = PAGER_WRITER_CACHEMOD;
39260 ** sub-journal is implemented in-memory if pPager is an in-memory database,
39263 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
39266 if( pPager->errCode ) return pPager->errCode;
39267 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
39268 pPager->subjInMemory = (u8)subjInMemory;
39270 if( ALWAYS(pPager->eState==PAGER_READER) ){
39271 assert( pPager->pInJournal==0 );
39273 if( pagerUseWal(pPager) ){
39277 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
39278 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
39282 sqlite3WalExclusiveMode(pPager->pWal, 1);
39290 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
39297 rc = pagerLockDb(pPager, RESERVED_LOCK);
39299 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
39313 pPager->eState = PAGER_WRITER_LOCKED;
39314 pPager->dbHintSize = pPager->dbSize;
39315 pPager->dbFileSize = pPager->dbSize;
39316 pPager->dbOrigSize = pPager->dbSize;
39317 pPager->journalOff = 0;
39320 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
39321 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
39322 assert( assert_pager_state(pPager) );
39325 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
39338 Pager *pPager = pPg->pPager;
39345 assert( pPager->eState==PAGER_WRITER_LOCKED
39346 || pPager->eState==PAGER_WRITER_CACHEMOD
39347 || pPager->eState==PAGER_WRITER_DBMOD
39349 assert( assert_pager_state(pPager) );
39353 if( NEVER(pPager->errCode) ) return pPager->errCode;
39357 if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
39366 assert( !pagerUseWal(pPager) );
39367 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
39378 if( pPager->eState==PAGER_WRITER_LOCKED ){
39379 rc = pager_open_journal(pPager);
39382 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
39383 assert( assert_pager_state(pPager) );
39389 if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
39390 assert( pagerUseWal(pPager)==0 );
39391 if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
39394 i64 iOff = pPager->journalOff;
39399 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
39401 assert( pPager->journalHdr<=pPager->journalOff );
39402 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
39403 cksum = pager_cksum(pPager, (u8*)pData2);
39414 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
39416 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
39418 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
39421 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
39422 pPager->journalOff, pPager->pageSize));
39425 PAGERID(pPager), pPg->pgno,
39428 pPager->journalOff += 8 + pPager->pageSize;
39429 pPager->nRec++;
39430 assert( pPager->pInJournal!=0 );
39431 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
39434 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
39440 if( pPager->eState!=PAGER_WRITER_DBMOD ){
39444 PAGERID(pPager), pPg->pgno,
39461 if( pPager->dbSize<pPg->pgno ){
39462 pPager->dbSize = pPg->pgno;
39485 Pager *pPager = pPg->pPager;
39486 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
39488 assert( pPager->eState>=PAGER_WRITER_LOCKED );
39489 assert( pPager->eState!=PAGER_ERROR );
39490 assert( assert_pager_state(pPager) );
39504 assert( pPager->doNotSyncSpill==0 );
39505 pPager->doNotSyncSpill++;
39513 nPageCount = pPager->dbSize;
39528 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
39529 if( pg!=PAGER_MJ_PGNO(pPager) ){
39530 rc = sqlite3PagerGet(pPager, pg, &pPage);
39539 }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
39556 PgHdr *pPage = pager_lookup(pPager, pg1+ii);
39564 assert( pPager->doNotSyncSpill==1 );
39565 pPager->doNotSyncSpill--;
39598 Pager *pPager = pPg->pPager;
39599 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
39600 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
39601 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
39623 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
39626 assert( pPager->eState==PAGER_WRITER_CACHEMOD
39627 || pPager->eState==PAGER_WRITER_DBMOD
39629 assert( assert_pager_state(pPager) );
39649 if( !pPager->changeCountDone && pPager->dbSize>0 ){
39653 assert( !pPager->tempFile && isOpen(pPager->fd) );
39656 rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
39670 change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
39683 assert( pPager->dbFileSize>0 );
39684 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
39686 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
39689 pPager->changeCountDone = 1;
39692 pPager->changeCountDone = 1;
39709 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
39712 if( pPager->noSync ){
39715 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
39731 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
39733 assert( pPager->eState==PAGER_WRITER_CACHEMOD
39734 || pPager->eState==PAGER_WRITER_DBMOD
39735 || pPager->eState==PAGER_WRITER_LOCKED
39737 assert( assert_pager_state(pPager) );
39738 if( 0==pagerUseWal(pPager) ){
39739 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
39745 ** Sync the database file for the pager pPager. zMaster points to the name
39771 Pager *pPager, /* Pager object */
39777 assert( pPager->eState==PAGER_WRITER_LOCKED
39778 || pPager->eState==PAGER_WRITER_CACHEMOD
39779 || pPager->eState==PAGER_WRITER_DBMOD
39780 || pPager->eState==PAGER_ERROR
39782 assert( assert_pager_state(pPager) );
39785 if( NEVER(pPager->errCode) ) return pPager->errCode;
39788 pPager->zFilename, zMaster, pPager->dbSize));
39791 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
39798 sqlite3BackupRestart(pPager->pBackup);
39800 if( pagerUseWal(pPager) ){
39801 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
39803 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1,
39804 (pPager->fullSync ? pPager->sync_flags : 0)
39808 sqlite3PcacheCleanAll(pPager->pPCache);
39836 assert( isOpen(pPager->jfd)
39837 || pPager->journalMode==PAGER_JOURNALMODE_OFF
39838 || pPager->journalMode==PAGER_JOURNALMODE_WAL
39840 if( !zMaster && isOpen(pPager->jfd)
39841 && pPager->journalOff==jrnlBufferSize(pPager)
39842 && pPager->dbSize>=pPager->dbOrigSize
39843 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
39851 rc = pager_incr_changecounter(pPager, 1);
39853 rc = sqlite3JournalCreate(pPager->jfd);
39855 rc = pager_incr_changecounter(pPager, 0);
39859 rc = pager_incr_changecounter(pPager, 0);
39874 if( pPager->dbSize<pPager->dbOrigSize
39875 && pPager->journalMode!=PAGER_JOURNALMODE_OFF
39878 const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
39879 const Pgno dbSize = pPager->dbSize; /* Database image size */
39880 pPager->dbSize = pPager->dbOrigSize;
39881 for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
39882 if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
39884 rc = sqlite3PagerGet(pPager, i, &pPage);
39891 pPager->dbSize = dbSize;
39899 rc = writeMasterJournal(pPager, zMaster);
39913 rc = syncJournal(pPager, 0);
39916 rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
39921 sqlite3PcacheCleanAll(pPager->pPCache);
39926 if( pPager->dbSize!=pPager->dbFileSize ){
39927 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
39928 assert( pPager->eState==PAGER_WRITER_DBMOD );
39929 rc = pager_truncate(pPager, nNew);
39934 if( !pPager->noSync && !noSync ){
39935 rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
39937 IOTRACE(("DBSYNC %p\n", pPager))
39942 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
39943 pPager->eState = PAGER_WRITER_FINISHED;
39964 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
39970 if( NEVER(pPager->errCode) ) return pPager->errCode;
39972 assert( pPager->eState==PAGER_WRITER_LOCKED
39973 || pPager->eState==PAGER_WRITER_FINISHED
39974 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
39976 assert( assert_pager_state(pPager) );
39989 if( pPager->eState==PAGER_WRITER_LOCKED
39990 && pPager->exclusiveMode
39991 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
39993 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
39994 pPager->eState = PAGER_READER;
39998 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
39999 rc = pager_end_transaction(pPager, pPager->setMaster);
40000 return pager_error(pPager, rc);
40029 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
40031 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
40037 assert( assert_pager_state(pPager) );
40038 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
40039 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
40041 if( pagerUseWal(pPager) ){
40043 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
40044 rc2 = pager_end_transaction(pPager, pPager->setMaster);
40046 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
40047 rc = pager_end_transaction(pPager, 0);
40049 rc = pager_playback(pPager, 0);
40052 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
40058 return pager_error(pPager, rc);
40065 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
40066 return pPager->readOnly;
40072 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
40073 return sqlite3PcacheRefCount(pPager->pPCache);
40080 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
40081 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
40083 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
40084 + sqlite3MallocSize(pPager)
40085 + pPager->pageSize;
40099 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
40101 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
40102 a[1] = sqlite3PcachePagecount(pPager->pPCache);
40103 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
40104 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
40105 a[4] = pPager->eState;
40106 a[5] = pPager->errCode;
40107 a[6] = pPager->nHit;
40108 a[7] = pPager->nMiss;
40109 a[8] = 0; /* Used to be pPager->nOvfl */
40110 a[9] = pPager->nRead;
40111 a[10] = pPager->nWrite;
40119 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
40133 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
40135 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
40137 assert( pPager->eState>=PAGER_WRITER_LOCKED );
40138 assert( assert_pager_state(pPager) );
40140 if( nSavepoint>nCurrent && pPager->useJournal ){
40149 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
40155 pPager->aSavepoint = aNew;
40159 aNew[ii].nOrig = pPager->dbSize;
40160 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
40161 aNew[ii].iOffset = pPager->journalOff;
40163 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
40165 aNew[ii].iSubRec = pPager->nSubRec;
40166 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
40170 if( pagerUseWal(pPager) ){
40171 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
40173 pPager->nSavepoint = ii+1;
40175 assert( pPager->nSavepoint==nSavepoint );
40176 assertTruncateConstraint(pPager);
40212 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
40213 int rc = pPager->errCode; /* Return code */
40218 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
40227 for(ii=nNew; ii<pPager->nSavepoint; ii++){
40228 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
40230 pPager->nSavepoint = nNew;
40235 if( nNew==0 && isOpen(pPager->sjfd) ){
40237 if( sqlite3IsMemJournal(pPager->sjfd) ){
40238 rc = sqlite3OsTruncate(pPager->sjfd, 0);
40241 pPager->nSubRec = 0;
40249 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
40250 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
40251 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
40262 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager){
40263 return pPager->zFilename;
40269 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
40270 return pPager->pVfs;
40278 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
40279 return pPager->fd;
40285 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
40286 return pPager->zJournal;
40293 SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
40294 return pPager->noSync;
40302 Pager *pPager,
40308 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
40309 pPager->xCodec = pPager->memDb ? 0 : xCodec;
40310 pPager->xCodecSizeChng = xCodecSizeChng;
40311 pPager->xCodecFree = xCodecFree;
40312 pPager->pCodec = pCodec;
40313 pagerReportSize(pPager);
40315 SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){
40316 return pPager->pCodec;
40346 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
40353 assert( pPager->eState==PAGER_WRITER_CACHEMOD
40354 || pPager->eState==PAGER_WRITER_DBMOD
40356 assert( assert_pager_state(pPager) );
40392 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
40393 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
40404 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
40414 pPgOld = pager_lookup(pPager, pgno);
40421 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
40457 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
40459 if( needSyncPgno<=pPager->dbOrigSize ){
40460 assert( pPager->pTmpSpace!=0 );
40461 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
40478 assert( pPg->nRef>0 || pPg->pPager->memDb );
40500 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
40506 if( eMode>=0 && !pPager->tempFile ){
40507 pPager->exclusiveMode = (u8)eMode;
40509 return (int)pPager->exclusiveMode;
40532 SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
40533 u8 eOld = pPager->journalMode; /* Prior journalmode */
40538 print_pager_state(pPager);
40554 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
40569 assert( pPager->eState!=PAGER_ERROR );
40570 pPager->journalMode = (u8)eMode;
40583 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
40584 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
40594 sqlite3OsClose(pPager->jfd);
40595 if( pPager->eLock>=RESERVED_LOCK ){
40596 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
40599 int state = pPager->eState;
40602 rc = sqlite3PagerSharedLock(pPager);
40604 if( pPager->eState==PAGER_READER ){
40606 rc = pagerLockDb(pPager, RESERVED_LOCK);
40609 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
40612 pagerUnlockDb(pPager, SHARED_LOCK);
40614 pager_unlock(pPager);
40616 assert( state==pPager->eState );
40622 return (int)pPager->journalMode;
40628 SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
40629 return (int)pPager->journalMode;
40637 SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
40638 assert( assert_pager_state(pPager) );
40639 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
40640 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
40650 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
40652 pPager->journalSizeLimit = iLimit;
40654 return pPager->journalSizeLimit;
40658 ** Return a pointer to the pPager->pBackup variable. The backup module
40663 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
40664 return &pPager->pBackup;
40671 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager){
40673 if( pPager->pWal ){
40674 u8 *zBuf = (u8 *)pPager->pTmpSpace;
40675 rc = sqlite3WalCheckpoint(pPager->pWal,
40676 (pPager->noSync ? 0 : pPager->sync_flags),
40677 pPager->pageSize, zBuf
40683 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
40684 return sqlite3WalCallback(pPager->pWal);
40691 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
40692 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
40712 Pager *pPager, /* Pager object */
40717 assert( assert_pager_state(pPager) );
40718 assert( pPager->eState==PAGER_OPEN || pbOpen );
40719 assert( pPager->eState==PAGER_READER || !pbOpen );
40721 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
40723 if( !pPager->tempFile && !pPager->pWal ){
40724 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
40727 sqlite3OsClose(pPager->jfd);
40733 rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, &pPager->pWal);
40735 pPager->journalMode = PAGER_JOURNALMODE_WAL;
40736 pPager->eState = PAGER_OPEN;
40754 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager){
40757 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
40763 if( !pPager->pWal ){
40765 rc = pagerLockDb(pPager, SHARED_LOCK);
40768 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
40772 rc = sqlite3WalOpen(pPager->pVfs, pPager->fd,
40773 pPager->zWal, &pPager->pWal);
40780 if( rc==SQLITE_OK && pPager->pWal ){
40781 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
40783 rc = sqlite3WalClose(pPager->pWal,
40784 (pPager->noSync ? 0 : pPager->sync_flags),
40785 pPager->pageSize, (u8*)pPager->pTmpSpace
40787 pPager->pWal = 0;
40791 pagerUnlockDb(pPager, SQLITE_LOCK_SHARED);
40807 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
43925 ** global SQLITE_MUTEX_STATIC_MASTER mutex. The pPager field
43949 Pager *pPager; /* The page cache */
44172 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
45313 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
45355 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
45612 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
46084 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
46098 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
46283 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
46284 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
46333 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
46336 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
46342 sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
46347 pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager);
46376 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
46439 if( pBt && pBt->pPager ){
46440 sqlite3PagerClose(pBt->pPager);
46549 sqlite3PagerClose(pBt->pPager);
46588 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
46606 sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync);
46621 assert( pBt && pBt->pPager );
46622 rc = sqlite3PagerNosync(pBt->pPager);
46668 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
46703 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
46791 rc = sqlite3PagerSharedLock(pBt->pPager);
46800 sqlite3PagerPagecount(pBt->pPager, &nPageFile);
46838 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
46877 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
46937 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
47089 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
47148 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
47282 Pager *pPager = pBt->pPager;
47293 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
47461 sqlite3PagerTruncateImage(pBt->pPager, iLastPg);
47506 Pager *pPager = pBt->pPager;
47507 VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
47549 sqlite3PagerTruncateImage(pBt->pPager, nFin);
47553 sqlite3PagerRollback(pPager);
47557 assert( nRef==sqlite3PagerRefcount(pPager) );
47605 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
47676 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
47791 rc2 = sqlite3PagerRollback(pBt->pPager);
47802 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
47848 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
47872 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
48415 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
51880 return p->pBt->pPager;
51990 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
52295 nRef = sqlite3PagerRefcount(pBt->pPager);
52297 sCheck.pPager = pBt->pPager;
52364 if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
52367 nRef, sqlite3PagerRefcount(pBt->pPager)
52393 assert( p->pBt->pPager!=0 );
52394 return sqlite3PagerFilename(p->pBt->pPager);
52406 assert( p->pBt->pPager!=0 );
52407 return sqlite3PagerJournalname(p->pBt->pPager);
52433 rc = sqlite3PagerCheckpoint(pBt->pPager);
59981 Pager *pPager; /* Pager associated with pBt */
59984 const char *zFilename; /* Name of database file for pPager */
64761 Pager *pPager; /* Pager associated with pBt */
64764 const char *zFilename; /* Name of database file for pPager */
64798 u.cd.pPager = sqlite3BtreePager(u.cd.pBt);
64799 u.cd.eOld = sqlite3PagerGetJournalMode(u.cd.pPager);
64801 if( !sqlite3PagerOkToChangeJournalMode(u.cd.pPager) ) u.cd.eNew = u.cd.eOld;
64804 u.cd.zFilename = sqlite3PagerFilename(u.cd.pPager);
64811 || !sqlite3PagerWalSupported(u.cd.pPager)) /* No shared-memory support */
64834 rc = sqlite3PagerCloseWal(u.cd.pPager);
64836 sqlite3PagerSetJournalMode(u.cd.pPager, u.cd.eNew);
64841 sqlite3PagerSetJournalMode(u.cd.pPager, PAGER_JOURNALMODE_OFF);
64858 u.cd.eNew = sqlite3PagerSetJournalMode(u.cd.pPager, u.cd.eNew);
73073 Pager *pPager;
73082 pPager = sqlite3BtreePager(aNew->pBt);
73083 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
84764 Pager *pPager;
84777 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
84778 sqlite3PagerLockingMode(pPager, eMode);
84782 pPager = sqlite3BtreePager(pDb->pBt);
84783 eMode = sqlite3PagerLockingMode(pPager, eMode);
84851 Pager *pPager = sqlite3BtreePager(pDb->pBt);
84857 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
85058 Pager *pPager = sqlite3BtreePager(pDb->pBt);
85060 sqlite3_file *pFile = sqlite3PagerFile(pPager);
85072 Pager *pPager = sqlite3BtreePager(pDb->pBt);
85073 sqlite3_file *pFile = sqlite3PagerFile(pPager);
85703 Pager *pPager;
85709 if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
105621 Pager *pPager;
105624 pPager = sqlite3BtreePager(pBtree);
105625 assert( pPager!=0 );
105626 fd = sqlite3PagerFile(pPager);