Lines Matching defs:pPager
8691 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
8708 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
8710 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
8727 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
8730 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
8731 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
8732 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
8734 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*);
8735 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
8736 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
8737 SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
8738 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);
8809 Pager *pPager; /* The pager this page is part of */
13125 Pager *pPager = sqlite3BtreePager(pBt);
13126 totalUsed += sqlite3PagerMemUsed(pPager);
38258 ** the page number and the pPager->pageSize bytes of data for the page.
38275 #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
38281 #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
38292 # define MEMDB pPager->memDb
38306 ** if( isOpen(pPager->jfd) ){ ...
38310 ** if( pPager->jfd->pMethods ){ ...
38319 static int pagerUseWal(Pager *pPager){
38320 return (pPager->pWal!=0);
38334 ** assert( assert_pager_state(pPager) );
38340 Pager *pPager = p;
38357 assert( p->tempFile==0 || pPager->changeCountDone );
38385 assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
38391 assert( pPager->errCode==SQLITE_OK );
38392 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
38396 assert( pPager->errCode==SQLITE_OK );
38403 assert( pPager->errCode==SQLITE_OK );
38404 if( !pagerUseWal(pPager) ){
38407 assert( pPager->dbSize==pPager->dbOrigSize );
38408 assert( pPager->dbOrigSize==pPager->dbFileSize );
38409 assert( pPager->dbOrigSize==pPager->dbHintSize );
38410 assert( pPager->setMaster==0 );
38415 assert( pPager->errCode==SQLITE_OK );
38416 if( !pagerUseWal(pPager) ){
38428 assert( pPager->dbOrigSize==pPager->dbFileSize );
38429 assert( pPager->dbOrigSize==pPager->dbHintSize );
38434 assert( pPager->errCode==SQLITE_OK );
38435 assert( !pagerUseWal(pPager) );
38441 assert( pPager->dbOrigSize<=pPager->dbHintSize );
38446 assert( pPager->errCode==SQLITE_OK );
38447 assert( !pagerUseWal(pPager) );
38459 assert( pPager->errCode!=SQLITE_OK );
38460 assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
38473 ** to "print *pPager" in gdb:
38475 ** (gdb) printf "%s", print_pager_state(pPager)
38530 Pager *pPager = pPg->pPager;
38532 for(i=0; i<pPager->nSavepoint; i++){
38533 PagerSavepoint *p = &pPager->aSavepoint[i];
38545 return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
38589 static int pagerUnlockDb(Pager *pPager, int eLock){
38592 assert( !pPager->exclusiveMode || pPager->eLock==eLock );
38594 assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
38595 if( isOpen(pPager->fd) ){
38596 assert( pPager->eLock>=eLock );
38597 rc = sqlite3OsUnlock(pPager->fd, eLock);
38598 if( pPager->eLock!=UNKNOWN_LOCK ){
38599 pPager->eLock = (u8)eLock;
38601 IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
38616 static int pagerLockDb(Pager *pPager, int eLock){
38620 if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
38621 rc = sqlite3OsLock(pPager->fd, eLock);
38622 if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
38623 pPager->eLock = (u8)eLock;
38624 IOTRACE(("LOCK %p %d\n", pPager, eLock))
38640 ** an error to call this function if pPager is opened on an in-memory
38648 static int jrnlBufferSize(Pager *pPager){
38650 if( !pPager->tempFile ){
38655 assert( isOpen(pPager->fd) );
38656 dc = sqlite3OsDeviceCharacteristics(pPager->fd);
38657 nSector = pPager->sectorSize;
38658 szPage = pPager->pageSize;
38667 return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
38689 return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
38702 Pager *pPager = pPg->pPager;
38703 assert( pPager->eState!=PAGER_ERROR );
38715 ** When this is called the journal file for pager pPager must be open.
38779 ** following the value in pPager->journalOff, assuming a sector
38780 ** size of pPager->sectorSize bytes.
38792 static i64 journalHdrOffset(Pager *pPager){
38794 i64 c = pPager->journalOff;
38796 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
38798 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
38800 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
38825 static int zeroJournalHdr(Pager *pPager, int doTruncate){
38827 assert( isOpen(pPager->jfd) );
38828 if( pPager->journalOff ){
38829 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
38831 IOTRACE(("JZEROHDR %p\n", pPager))
38833 rc = sqlite3OsTruncate(pPager->jfd, 0);
38836 rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
38838 if( rc==SQLITE_OK && !pPager->noSync ){
38839 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
38850 rc = sqlite3OsFileSize(pPager->jfd, &sz);
38852 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
38874 static int writeJournalHdr(Pager *pPager){
38876 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
38877 u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
38881 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
38883 if( nHeader>JOURNAL_HDR_SZ(pPager) ){
38884 nHeader = JOURNAL_HDR_SZ(pPager);
38891 for(ii=0; ii<pPager->nSavepoint; ii++){
38892 if( pPager->aSavepoint[ii].iHdrOffset==0 ){
38893 pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
38897 pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
38919 assert( isOpen(pPager->fd) || pPager->noSync );
38920 if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
38921 || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
38930 sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
38931 put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
38933 put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
38935 put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
38938 put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
38965 for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
38966 IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
38967 rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
38968 assert( pPager->journalHdr <= pPager->journalOff );
38969 pPager->journalOff += nHeader;
38979 ** pPager->journalOff. See comments above function writeJournalHdr() for
38984 ** database before the transaction began, in pages. Also, pPager->cksumInit
38993 Pager *pPager, /* Pager object */
39003 assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
39009 pPager->journalOff = journalHdrOffset(pPager);
39010 if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
39013 iHdrOff = pPager->journalOff;
39020 if( isHot || iHdrOff!=pPager->journalHdr ){
39021 rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
39034 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
39035 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
39036 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
39041 if( pPager->journalOff==0 ){
39046 if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
39047 || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
39057 iPageSize = pPager->pageSize;
39081 rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
39090 pPager->sectorSize = iSectorSize;
39093 pPager->journalOff += JOURNAL_HDR_SZ(pPager);
39100 ** pPager at the current location. The master journal name must be the last
39117 static int writeMasterJournal(Pager *pPager, const char *zMaster){
39124 assert( pPager->setMaster==0 );
39125 assert( !pagerUseWal(pPager) );
39128 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
39129 || pPager->journalMode==PAGER_JOURNALMODE_OFF
39133 pPager->setMaster = 1;
39134 assert( isOpen(pPager->jfd) );
39135 assert( pPager->journalHdr <= pPager->journalOff );
39146 if( pPager->fullSync ){
39147 pPager->journalOff = journalHdrOffset(pPager);
39149 iHdrOff = pPager->journalOff;
39154 if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
39155 || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
39156 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
39157 || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
39158 || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
39162 pPager->journalOff += (nMaster+20);
39174 if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
39175 && jrnlSize>pPager->journalOff
39177 rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
39187 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
39193 (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
39200 static void pager_reset(Pager *pPager){
39201 sqlite3BackupRestart(pPager->pBackup);
39202 sqlite3PcacheClear(pPager->pPCache);
39210 static void releaseAllSavepoints(Pager *pPager){
39212 for(ii=0; ii<pPager->nSavepoint; ii++){
39213 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
39215 if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
39216 sqlite3OsClose(pPager->sjfd);
39218 sqlite3_free(pPager->aSavepoint);
39219 pPager->aSavepoint = 0;
39220 pPager->nSavepoint = 0;
39221 pPager->nSubRec = 0;
39229 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
39233 for(ii=0; ii<pPager->nSavepoint; ii++){
39234 PagerSavepoint *p = &pPager->aSavepoint[ii];
39261 static void pager_unlock(Pager *pPager){
39263 assert( pPager->eState==PAGER_READER
39264 || pPager->eState==PAGER_OPEN
39265 || pPager->eState==PAGER_ERROR
39268 sqlite3BitvecDestroy(pPager->pInJournal);
39269 pPager->pInJournal = 0;
39270 releaseAllSavepoints(pPager);
39272 if( pagerUseWal(pPager) ){
39273 assert( !isOpen(pPager->jfd) );
39274 sqlite3WalEndReadTransaction(pPager->pWal);
39275 pPager->eState = PAGER_OPEN;
39276 }else if( !pPager->exclusiveMode ){
39278 int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
39292 || 1!=(pPager->journalMode & 5)
39294 sqlite3OsClose(pPager->jfd);
39302 rc = pagerUnlockDb(pPager, NO_LOCK);
39303 if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
39304 pPager->eLock = UNKNOWN_LOCK;
39311 assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
39312 pPager->changeCountDone = 0;
39313 pPager->eState = PAGER_OPEN;
39321 if( pPager->errCode ){
39323 pager_reset(pPager);
39324 pPager->changeCountDone = pPager->tempFile;
39325 pPager->eState = PAGER_OPEN;
39326 pPager->errCode = SQLITE_OK;
39329 pPager->journalOff = 0;
39330 pPager->journalHdr = 0;
39331 pPager->setMaster = 0;
39353 static int pager_error(Pager *pPager, int rc){
39357 pPager->errCode==SQLITE_FULL ||
39358 pPager->errCode==SQLITE_OK ||
39359 (pPager->errCode & 0xff)==SQLITE_IOERR
39362 pPager->errCode = rc;
39363 pPager->eState = PAGER_ERROR;
39421 static int pager_end_transaction(Pager *pPager, int hasMaster){
39438 assert( assert_pager_state(pPager) );
39439 assert( pPager->eState!=PAGER_ERROR );
39440 if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
39444 releaseAllSavepoints(pPager);
39445 assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
39446 if( isOpen(pPager->jfd) ){
39447 assert( !pagerUseWal(pPager) );
39450 if( sqlite3IsMemJournal(pPager->jfd) ){
39451 assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
39452 sqlite3OsClose(pPager->jfd);
39453 }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
39454 if( pPager->journalOff==0 ){
39457 rc = sqlite3OsTruncate(pPager->jfd, 0);
39459 pPager->journalOff = 0;
39460 }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
39461 || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
39463 rc = zeroJournalHdr(pPager, hasMaster);
39464 pPager->journalOff = 0;
39471 assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
39472 || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
39473 || pPager->journalMode==PAGER_JOURNALMODE_WAL
39475 sqlite3OsClose(pPager->jfd);
39476 if( !pPager->tempFile ){
39477 rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
39483 sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
39484 if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
39485 PgHdr *p = pager_lookup(pPager, 1);
39493 sqlite3BitvecDestroy(pPager->pInJournal);
39494 pPager->pInJournal = 0;
39495 pPager->nRec = 0;
39496 sqlite3PcacheCleanAll(pPager->pPCache);
39497 sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
39499 if( pagerUseWal(pPager) ){
39504 rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
39507 if( !pPager->exclusiveMode
39508 && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
39510 rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
39511 pPager->changeCountDone = 0;
39513 pPager->eState = PAGER_READER;
39514 pPager->setMaster = 0;
39536 static void pagerUnlockAndRollback(Pager *pPager){
39537 if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
39538 assert( assert_pager_state(pPager) );
39539 if( pPager->eState>=PAGER_WRITER_LOCKED ){
39541 sqlite3PagerRollback(pPager);
39543 }else if( !pPager->exclusiveMode ){
39544 assert( pPager->eState==PAGER_READER );
39545 pager_end_transaction(pPager, 0);
39548 pager_unlock(pPager);
39552 ** Parameter aData must point to a buffer of pPager->pageSize bytes
39554 ** page of data and the current value of pPager->cksumInit.
39557 ** random initial value (pPager->cksumInit) and every 200th byte
39558 ** of the page data, starting with byte offset (pPager->pageSize%200).
39570 static u32 pager_cksum(Pager *pPager, const u8 *aData){
39571 u32 cksum = pPager->cksumInit; /* Checksum value to return */
39572 int i = pPager->pageSize-200; /* Loop counter */
39585 static void pagerReportSize(Pager *pPager){
39586 if( pPager->xCodecSizeChng ){
39587 pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
39588 (int)pPager->nReserve);
39633 Pager *pPager, /* The pager being played back */
39652 aData = pPager->pTmpSpace;
39654 assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
39662 assert( pPager->eState>=PAGER_WRITER_CACHEMOD
39663 || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
39665 assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
39670 jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
39673 rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
39675 *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
39682 if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
39686 if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
39692 if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
39706 if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
39707 pPager->nReserve = ((u8*)aData)[20];
39708 pagerReportSize(pPager);
39746 if( pagerUseWal(pPager) ){
39749 pPg = pager_lookup(pPager, pgno);
39752 assert( pPager->eState!=PAGER_OPEN || pPg==0 );
39754 PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
39758 isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
39762 if( isOpen(pPager->fd)
39763 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
39766 i64 ofst = (pgno-1)*(i64)pPager->pageSize;
39768 assert( !pagerUseWal(pPager) );
39769 rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
39770 if( pgno>pPager->dbFileSize ){
39771 pPager->dbFileSize = pgno;
39773 if( pPager->pBackup ){
39774 CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
39775 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
39776 CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
39796 assert( pPager->doNotSpill==0 );
39797 pPager->doNotSpill++;
39798 rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
39799 assert( pPager->doNotSpill==1 );
39800 pPager->doNotSpill--;
39814 memcpy(pData, (u8*)aData, pPager->pageSize);
39815 pPager->xReiniter(pPg);
39816 if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
39836 assert( !pagerUseWal(pPager) );
39844 memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
39848 CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
39897 static int pager_delmaster(Pager *pPager, const char *zMaster){
39898 sqlite3_vfs *pVfs = pPager->pVfs;
39994 ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
40007 static int pager_truncate(Pager *pPager, Pgno nPage){
40009 assert( pPager->eState!=PAGER_ERROR );
40010 assert( pPager->eState!=PAGER_READER );
40012 if( isOpen(pPager->fd)
40013 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
40016 int szPage = pPager->pageSize;
40017 assert( pPager->eLock==EXCLUSIVE_LOCK );
40019 rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
40023 rc = sqlite3OsTruncate(pPager->fd, newSize);
40025 char *pTmp = pPager->pTmpSpace;
40030 rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
40033 pPager->dbFileSize = nPage;
40054 static void setSectorSize(Pager *pPager){
40055 assert( isOpen(pPager->fd) || pPager->tempFile );
40057 if( !pPager->tempFile ){
40062 pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
40064 if( pPager->sectorSize<32 ){
40065 pPager->sectorSize = 512;
40067 if( pPager->sectorSize>MAX_SECTOR_SIZE ){
40069 pPager->sectorSize = MAX_SECTOR_SIZE;
40093 ** + pPager->pageSize bytes of data.
40130 static int pager_playback(Pager *pPager, int isHot){
40131 sqlite3_vfs *pVfs = pPager->pVfs;
40144 assert( isOpen(pPager->jfd) );
40145 rc = sqlite3OsFileSize(pPager->jfd, &szJ);
40157 ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
40161 zMaster = pPager->pTmpSpace;
40162 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
40170 pPager->journalOff = 0;
40183 rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
40197 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
40198 nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
40216 pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
40217 nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
40223 if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
40224 rc = pager_truncate(pPager, mxPg);
40228 pPager->dbSize = mxPg;
40236 pager_reset(pPager);
40239 rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
40243 pPager->journalOff = szJ;
40274 pPager->fd->pMethods==0 ||
40275 sqlite3OsFileControl(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0)>=SQLITE_OK
40287 pPager->changeCountDone = pPager->tempFile;
40290 zMaster = pPager->pTmpSpace;
40291 rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
40295 && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
40297 rc = sqlite3PagerSync(pPager);
40300 rc = pager_end_transaction(pPager, zMaster[0]!='\0');
40307 rc = pager_delmaster(pPager, zMaster);
40315 setSectorSize(pPager);
40332 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
40336 int pgsz = pPager->pageSize; /* Number of bytes to read */
40338 assert( pPager->eState>=PAGER_READER && !MEMDB );
40339 assert( isOpen(pPager->fd) );
40341 if( NEVER(!isOpen(pPager->fd)) ){
40342 assert( pPager->tempFile );
40343 memset(pPg->pData, 0, pPager->pageSize);
40347 if( pagerUseWal(pPager) ){
40349 rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
40352 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
40353 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
40366 ** pPager->dbFileVers[] with all 0xff bytes should suffice.
40373 memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
40376 memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
40379 CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
40382 PAGER_INCR(pPager->nRead);
40383 IOTRACE(("PGIN %p %d\n", pPager, pgno));
40385 PAGERID(pPager), pgno, pager_pagehash(pPg)));
40396 ** needed, as determined by the pPager->changeCountDone state variable.
40402 change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
40427 Pager *pPager = (Pager *)pCtx;
40430 pPg = sqlite3PagerLookup(pPager, iPg);
40437 pPager->xReiniter(pPg);
40451 sqlite3BackupRestart(pPager->pBackup);
40459 static int pagerRollbackWal(Pager *pPager){
40470 pPager->dbSize = pPager->dbOrigSize;
40471 rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
40472 pList = sqlite3PcacheDirtyList(pPager->pPCache);
40475 rc = pagerUndoCallback((void *)pPager, pList->pgno);
40492 Pager *pPager, /* Pager object */
40503 assert( pPager->pWal );
40525 rc = sqlite3WalFrames(pPager->pWal,
40526 pPager->pageSize, pList, nTruncate, isCommit, syncFlags
40528 if( rc==SQLITE_OK && pPager->pBackup ){
40531 sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
40536 pList = sqlite3PcacheDirtyList(pPager->pPCache);
40553 static int pagerBeginReadTransaction(Pager *pPager){
40557 assert( pagerUseWal(pPager) );
40558 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
40565 sqlite3WalEndReadTransaction(pPager->pWal);
40567 rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
40569 pager_reset(pPager);
40585 static int pagerPagecount(Pager *pPager, Pgno *pnPage){
40594 assert( pPager->eState==PAGER_OPEN );
40595 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
40596 nPage = sqlite3WalDbsize(pPager->pWal);
40606 assert( isOpen(pPager->fd) || pPager->tempFile );
40607 if( isOpen(pPager->fd) ){
40608 int rc = sqlite3OsFileSize(pPager->fd, &n);
40613 nPage = (Pgno)(n / pPager->pageSize);
40623 if( nPage>pPager->mxPgno ){
40624 pPager->mxPgno = (Pgno)nPage;
40633 ** Check if the *-wal file that corresponds to the database opened by pPager
40650 static int pagerOpenWalIfPresent(Pager *pPager){
40652 assert( pPager->eState==PAGER_OPEN );
40653 assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
40655 if( !pPager->tempFile ){
40659 rc = pagerPagecount(pPager, &nPage);
40662 rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
40666 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
40671 testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
40672 rc = sqlite3PagerOpenWal(pPager, 0);
40673 }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
40674 pPager->journalMode = PAGER_JOURNALMODE_DELETE;
40718 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
40724 assert( pPager->eState!=PAGER_ERROR );
40725 assert( pPager->eState>=PAGER_WRITER_LOCKED );
40738 pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
40739 pPager->changeCountDone = pPager->tempFile;
40741 if( !pSavepoint && pagerUseWal(pPager) ){
40742 return pagerRollbackWal(pPager);
40745 /* Use pPager->journalOff as the effective size of the main rollback
40748 ** past pPager->journalOff is off-limits to us.
40750 szJ = pPager->journalOff;
40751 assert( pagerUseWal(pPager)==0 || szJ==0 );
40756 ** greater than the current database size (pPager->dbSize) but those
40760 if( pSavepoint && !pagerUseWal(pPager) ){
40762 pPager->journalOff = pSavepoint->iOffset;
40763 while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
40764 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
40768 pPager->journalOff = 0;
40776 while( rc==SQLITE_OK && pPager->journalOff<szJ ){
40780 rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
40784 ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
40789 && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
40791 nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
40793 for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
40794 rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
40798 assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
40806 i64 offset = pSavepoint->iSubRec*(4+pPager->pageSize);
40808 if( pagerUseWal(pPager) ){
40809 rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
40811 for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
40812 assert( offset==ii*(4+pPager->pageSize) );
40813 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
40820 pPager->journalOff = szJ;
40829 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
40830 sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
40878 Pager *pPager, /* The pager to set safety level for */
40884 pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
40885 pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
40886 if( pPager->noSync ){
40887 pPager->syncFlags = 0;
40888 pPager->ckptSyncFlags = 0;
40890 pPager->syncFlags = SQLITE_SYNC_FULL;
40891 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
40893 pPager->syncFlags = SQLITE_SYNC_NORMAL;
40894 pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
40896 pPager->syncFlags = SQLITE_SYNC_NORMAL;
40897 pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
40927 Pager *pPager, /* The pager object */
40939 rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
40966 Pager *pPager, /* Pager object */
40970 pPager->xBusyHandler = xBusyHandler;
40971 pPager->pBusyHandlerArg = pBusyHandlerArg;
41004 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
41019 if( (pPager->memDb==0 || pPager->dbSize==0)
41020 && sqlite3PcacheRefCount(pPager->pPCache)==0
41021 && pageSize && pageSize!=(u32)pPager->pageSize
41026 if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
41027 rc = sqlite3OsFileSize(pPager->fd, &nByte);
41035 pager_reset(pPager);
41036 pPager->dbSize = (Pgno)(nByte/pageSize);
41037 pPager->pageSize = pageSize;
41038 sqlite3PageFree(pPager->pTmpSpace);
41039 pPager->pTmpSpace = pNew;
41040 sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
41044 *pPageSize = pPager->pageSize;
41046 if( nReserve<0 ) nReserve = pPager->nReserve;
41048 pPager->nReserve = (i16)nReserve;
41049 pagerReportSize(pPager);
41062 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
41063 return pPager->pTmpSpace;
41073 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
41075 pPager->mxPgno = mxPage;
41077 assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
41078 assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
41079 return pPager->mxPgno;
41120 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
41123 assert( isOpen(pPager->fd) || pPager->tempFile );
41129 assert( !pagerUseWal(pPager) );
41131 if( isOpen(pPager->fd) ){
41132 IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
41133 rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
41148 SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
41149 assert( pPager->eState>=PAGER_READER );
41150 assert( pPager->eState!=PAGER_WRITER_FINISHED );
41151 *pnPage = (int)pPager->dbSize;
41169 static int pager_wait_on_lock(Pager *pPager, int locktype){
41177 assert( (pPager->eLock>=locktype)
41178 || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
41179 || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
41183 rc = pagerLockDb(pPager, locktype);
41184 }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
41189 ** Function assertTruncateConstraint(pPager) checks that one of the
41213 assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
41215 static void assertTruncateConstraint(Pager *pPager){
41216 sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
41219 # define assertTruncateConstraint(pPager)
41228 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
41229 assert( pPager->dbSize>=nPage );
41230 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
41231 pPager->dbSize = nPage;
41232 assertTruncateConstraint(pPager);
41238 ** syncs the journal file to disk, then sets pPager->journalHdr to the
41250 static int pagerSyncHotJournal(Pager *pPager){
41252 if( !pPager->noSync ){
41253 rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
41256 rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
41275 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
41276 u8 *pTmp = (u8 *)pPager->pTmpSpace;
41278 assert( assert_pager_state(pPager) );
41281 /* pPager->errCode = 0; */
41282 pPager->exclusiveMode = 0;
41284 sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
41285 pPager->pWal = 0;
41287 pager_reset(pPager);
41289 pager_unlock(pPager);
41302 if( isOpen(pPager->jfd) ){
41303 pager_error(pPager, pagerSyncHotJournal(pPager));
41305 pagerUnlockAndRollback(pPager);
41309 PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
41310 IOTRACE(("CLOSE %p\n", pPager))
41311 sqlite3OsClose(pPager->jfd);
41312 sqlite3OsClose(pPager->fd);
41314 sqlite3PcacheClose(pPager->pPCache);
41317 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
41320 assert( !pPager->aSavepoint && !pPager->pInJournal );
41321 assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
41323 sqlite3_free(pPager);
41378 static int syncJournal(Pager *pPager, int newHdr){
41381 assert( pPager->eState==PAGER_WRITER_CACHEMOD
41382 || pPager->eState==PAGER_WRITER_DBMOD
41384 assert( assert_pager_state(pPager) );
41385 assert( !pagerUseWal(pPager) );
41387 rc = sqlite3PagerExclusiveLock(pPager);
41390 if( !pPager->noSync ){
41391 assert( !pPager->tempFile );
41392 if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
41393 const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
41394 assert( isOpen(pPager->jfd) );
41424 put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
41426 iNextHdrOffset = journalHdrOffset(pPager);
41427 rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
41430 rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
41447 if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
41448 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
41449 IOTRACE(("JSYNC %p\n", pPager))
41450 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
41453 IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
41455 pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
41460 PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
41461 IOTRACE(("JSYNC %p\n", pPager))
41462 rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
41463 (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
41468 pPager->journalHdr = pPager->journalOff;
41470 pPager->nRec = 0;
41471 rc = writeJournalHdr(pPager);
41475 pPager->journalHdr = pPager->journalOff;
41483 sqlite3PcacheClearSyncFlags(pPager->pPCache);
41484 pPager->eState = PAGER_WRITER_DBMOD;
41485 assert( assert_pager_state(pPager) );
41521 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
41525 assert( !pagerUseWal(pPager) );
41526 assert( pPager->eState==PAGER_WRITER_DBMOD );
41527 assert( pPager->eLock==EXCLUSIVE_LOCK );
41533 if( !isOpen(pPager->fd) ){
41534 assert( pPager->tempFile && rc==SQLITE_OK );
41535 rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
41541 assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
41542 if( rc==SQLITE_OK && pPager->dbSize>pPager->dbHintSize ){
41543 sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
41544 sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
41545 pPager->dbHintSize = pPager->dbSize;
41559 if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
41560 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
41567 CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
41570 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
41577 memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
41579 if( pgno>pPager->dbFileSize ){
41580 pPager->dbFileSize = pgno;
41584 sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
41587 PAGERID(pPager), pgno, pager_pagehash(pList)));
41588 IOTRACE(("PGOUT %p %d\n", pPager, pgno));
41590 PAGER_INCR(pPager->nWrite);
41592 PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
41609 static int openSubJournal(Pager *pPager){
41611 if( !isOpen(pPager->sjfd) ){
41612 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
41613 sqlite3MemJournalOpen(pPager->sjfd);
41615 rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
41636 Pager *pPager = pPg->pPager;
41637 if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
41640 assert( pPager->useJournal );
41641 assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
41642 assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
41643 assert( pagerUseWal(pPager)
41645 || pPg->pgno>pPager->dbOrigSize
41647 rc = openSubJournal(pPager);
41653 i64 offset = pPager->nSubRec*(4+pPager->pageSize);
41656 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
41657 PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
41658 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
41660 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
41665 pPager->nSubRec++;
41666 assert( pPager->nSavepoint>0 );
41667 rc = addToSavepointBitvecs(pPager, pPg->pgno);
41692 Pager *pPager = (Pager *)p;
41695 assert( pPg->pPager==pPager );
41713 if( NEVER(pPager->errCode) ) return SQLITE_OK;
41714 if( pPager->doNotSpill ) return SQLITE_OK;
41715 if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
41720 if( pagerUseWal(pPager) ){
41726 rc = pagerWalFrames(pPager, pPg, 0, 0, 0);
41732 || pPager->eState==PAGER_WRITER_CACHEMOD
41734 rc = syncJournal(pPager, 1);
41765 rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
41773 rc = pager_write_pagelist(pPager, pPg);
41779 PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
41783 return pager_error(pPager, rc);
41827 Pager *pPager = 0; /* Pager object to allocate and return */
41914 ROUND8(sizeof(*pPager)) + /* Pager structure */
41929 pPager = (Pager*)(pPtr);
41930 pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
41931 pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
41932 pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
41933 pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
41934 pPager->zFilename = (char*)(pPtr += journalFileSize);
41935 assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
41940 pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri);
41941 memcpy(pPager->zFilename, zPathname, nPathname);
41942 memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
41943 memcpy(pPager->zJournal, zPathname, nPathname);
41944 memcpy(&pPager->zJournal[nPathname], "-journal", 8);
41945 sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal);
41947 pPager->zWal = &pPager->zJournal[nPathname+8+1];
41948 memcpy(pPager->zWal, zPathname, nPathname);
41949 memcpy(&pPager->zWal[nPathname], "-wal", 4);
41950 sqlite3FileSuffix3(pPager->zFilename, pPager->zWal);
41954 pPager->pVfs = pVfs;
41955 pPager->vfsFlags = vfsFlags;
41961 rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
41974 setSectorSize(pPager);
41976 if( szPageDflt<pPager->sectorSize ){
41977 if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
41980 szPageDflt = (u32)pPager->sectorSize;
41985 int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
42008 pPager->eState = PAGER_READER;
42009 pPager->eLock = EXCLUSIVE_LOCK;
42017 assert( pPager->memDb==0 );
42018 rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
42026 assert( !pPager->pTmpSpace );
42027 sqlite3OsClose(pPager->fd);
42028 sqlite3_free(pPager);
42036 !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
42038 PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
42039 IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
42041 pPager->useJournal = (u8)useJournal;
42042 pPager->noReadlock = (noReadlock && readOnly) ?1:0;
42043 /* pPager->stmtOpen = 0; */
42044 /* pPager->stmtInUse = 0; */
42045 /* pPager->nRef = 0; */
42046 /* pPager->stmtSize = 0; */
42047 /* pPager->stmtJSize = 0; */
42048 /* pPager->nPage = 0; */
42049 pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
42050 /* pPager->state = PAGER_UNLOCK; */
42052 assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
42054 /* pPager->errMask = 0; */
42055 pPager->tempFile = (u8)tempFile;
42059 pPager->exclusiveMode = (u8)tempFile;
42060 pPager->changeCountDone = pPager->tempFile;
42061 pPager->memDb = (u8)memDb;
42062 pPager->readOnly = (u8)readOnly;
42063 assert( useJournal || pPager->tempFile );
42064 pPager->noSync = pPager->tempFile;
42065 pPager->fullSync = pPager->noSync ?0:1;
42066 pPager->syncFlags = pPager->noSync ? 0 : SQLITE_SYNC_NORMAL;
42067 pPager->ckptSyncFlags = pPager->syncFlags;
42068 /* pPager->pFirst = 0; */
42069 /* pPager->pFirstSynced = 0; */
42070 /* pPager->pLast = 0; */
42071 pPager->nExtra = (u16)nExtra;
42072 pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
42073 assert( isOpen(pPager->fd) || tempFile );
42074 setSectorSize(pPager);
42076 pPager->journalMode = PAGER_JOURNALMODE_OFF;
42078 pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
42080 /* pPager->xBusyHandler = 0; */
42081 /* pPager->pBusyHandlerArg = 0; */
42082 pPager->xReiniter = xReinit;
42083 /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
42085 *ppPager = pPager;
42122 static int hasHotJournal(Pager *pPager, int *pExists){
42123 sqlite3_vfs * const pVfs = pPager->pVfs;
42126 int jrnlOpen = !!isOpen(pPager->jfd);
42128 assert( pPager->useJournal );
42129 assert( isOpen(pPager->fd) );
42130 assert( pPager->eState==PAGER_OPEN );
42132 assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
42138 rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
42151 rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
42161 rc = pagerPagecount(pPager, &nPage);
42165 if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
42166 sqlite3OsDelete(pVfs, pPager->zJournal, 0);
42167 if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
42179 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
42183 rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
42188 sqlite3OsClose(pPager->jfd);
42239 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
42247 assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
42248 assert( assert_pager_state(pPager) );
42249 assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
42250 if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
42252 if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
42256 assert( pPager->noReadlock==0 || pPager->readOnly );
42258 if( pPager->noReadlock==0 ){
42259 rc = pager_wait_on_lock(pPager, SHARED_LOCK);
42261 assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
42269 if( pPager->eLock<=SHARED_LOCK ){
42270 rc = hasHotJournal(pPager, &bHotJournal);
42291 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
42309 if( !isOpen(pPager->jfd) ){
42310 sqlite3_vfs * const pVfs = pPager->pVfs;
42313 pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
42317 assert( !pPager->tempFile );
42318 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
42319 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
42322 sqlite3OsClose(pPager->jfd);
42335 if( isOpen(pPager->jfd) ){
42337 rc = pagerSyncHotJournal(pPager);
42339 rc = pager_playback(pPager, 1);
42340 pPager->eState = PAGER_OPEN;
42342 }else if( !pPager->exclusiveMode ){
42343 pagerUnlockDb(pPager, SHARED_LOCK);
42363 pager_error(pPager, rc);
42367 assert( pPager->eState==PAGER_OPEN );
42368 assert( (pPager->eLock==SHARED_LOCK)
42369 || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
42373 if( !pPager->tempFile
42374 && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0)
42393 char dbFileVers[sizeof(pPager->dbFileVers)];
42395 rc = pagerPagecount(pPager, &nPage);
42399 IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
42400 rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
42408 if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
42409 pager_reset(pPager);
42416 rc = pagerOpenWalIfPresent(pPager);
42418 assert( pPager->pWal==0 || rc==SQLITE_OK );
42422 if( pagerUseWal(pPager) ){
42424 rc = pagerBeginReadTransaction(pPager);
42427 if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
42428 rc = pagerPagecount(pPager, &pPager->dbSize);
42434 pager_unlock(pPager);
42435 assert( pPager->eState==PAGER_OPEN );
42437 pPager->eState = PAGER_READER;
42450 static void pagerUnlockIfUnused(Pager *pPager){
42451 if( (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
42452 pagerUnlockAndRollback(pPager);
42457 ** Acquire a reference to page number pgno in pager pPager (a page
42507 Pager *pPager, /* The pager open on the database file */
42515 assert( pPager->eState>=PAGER_READER );
42516 assert( assert_pager_state(pPager) );
42524 if( pPager->errCode!=SQLITE_OK ){
42525 rc = pPager->errCode;
42527 rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
42538 assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
42540 if( (*ppPage)->pPager && !noContent ){
42543 assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
42544 PAGER_INCR(pPager->nHit);
42551 PAGER_INCR(pPager->nMiss);
42553 pPg->pPager = pPager;
42557 if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
42562 if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
42563 if( pgno>pPager->mxPgno ){
42575 if( pgno<=pPager->dbOrigSize ){
42576 TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
42579 TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
42583 memset(pPg->pData, 0, pPager->pageSize);
42584 IOTRACE(("ZERO %p %d\n", pPager, pgno));
42586 assert( pPg->pPager==pPager );
42602 pagerUnlockIfUnused(pPager);
42619 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
42621 assert( pPager!=0 );
42623 assert( pPager->pPCache!=0 );
42624 assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
42625 sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
42639 Pager *pPager = pPg->pPager;
42641 pagerUnlockIfUnused(pPager);
42650 ** Open the journal file for pager pPager and write a journal header
42667 static int pager_open_journal(Pager *pPager){
42669 sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
42671 assert( pPager->eState==PAGER_WRITER_LOCKED );
42672 assert( assert_pager_state(pPager) );
42673 assert( pPager->pInJournal==0 );
42678 if( NEVER(pPager->errCode) ) return pPager->errCode;
42680 if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
42681 pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
42682 if( pPager->pInJournal==0 ){
42687 if( !isOpen(pPager->jfd) ){
42688 if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
42689 sqlite3MemJournalOpen(pPager->jfd);
42693 (pPager->tempFile ?
42699 pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
42702 rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
42705 assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
42714 pPager->nRec = 0;
42715 pPager->journalOff = 0;
42716 pPager->setMaster = 0;
42717 pPager->journalHdr = 0;
42718 rc = writeJournalHdr(pPager);
42723 sqlite3BitvecDestroy(pPager->pInJournal);
42724 pPager->pInJournal = 0;
42726 assert( pPager->eState==PAGER_WRITER_LOCKED );
42727 pPager->eState = PAGER_WRITER_CACHEMOD;
42747 ** sub-journal is implemented in-memory if pPager is an in-memory database,
42750 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
42753 if( pPager->errCode ) return pPager->errCode;
42754 assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
42755 pPager->subjInMemory = (u8)subjInMemory;
42757 if( ALWAYS(pPager->eState==PAGER_READER) ){
42758 assert( pPager->pInJournal==0 );
42760 if( pagerUseWal(pPager) ){
42764 if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
42765 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
42769 sqlite3WalExclusiveMode(pPager->pWal, 1);
42777 rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
42784 rc = pagerLockDb(pPager, RESERVED_LOCK);
42786 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
42800 pPager->eState = PAGER_WRITER_LOCKED;
42801 pPager->dbHintSize = pPager->dbSize;
42802 pPager->dbFileSize = pPager->dbSize;
42803 pPager->dbOrigSize = pPager->dbSize;
42804 pPager->journalOff = 0;
42807 assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
42808 assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
42809 assert( assert_pager_state(pPager) );
42812 PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
42825 Pager *pPager = pPg->pPager;
42832 assert( pPager->eState==PAGER_WRITER_LOCKED
42833 || pPager->eState==PAGER_WRITER_CACHEMOD
42834 || pPager->eState==PAGER_WRITER_DBMOD
42836 assert( assert_pager_state(pPager) );
42840 if( NEVER(pPager->errCode) ) return pPager->errCode;
42844 if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
42857 if( pPager->eState==PAGER_WRITER_LOCKED ){
42858 rc = pager_open_journal(pPager);
42861 assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
42862 assert( assert_pager_state(pPager) );
42869 assert( !pagerUseWal(pPager) );
42876 if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
42877 assert( pagerUseWal(pPager)==0 );
42878 if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
42881 i64 iOff = pPager->journalOff;
42886 assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
42888 assert( pPager->journalHdr<=pPager->journalOff );
42889 CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
42890 cksum = pager_cksum(pPager, (u8*)pData2);
42901 rc = write32bits(pPager->jfd, iOff, pPg->pgno);
42903 rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
42905 rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
42908 IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
42909 pPager->journalOff, pPager->pageSize));
42912 PAGERID(pPager), pPg->pgno,
42915 pPager->journalOff += 8 + pPager->pageSize;
42916 pPager->nRec++;
42917 assert( pPager->pInJournal!=0 );
42918 rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
42921 rc |= addToSavepointBitvecs(pPager, pPg->pgno);
42927 if( pPager->eState!=PAGER_WRITER_DBMOD ){
42931 PAGERID(pPager), pPg->pgno,
42948 if( pPager->dbSize<pPg->pgno ){
42949 pPager->dbSize = pPg->pgno;
42972 Pager *pPager = pPg->pPager;
42973 Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
42975 assert( pPager->eState>=PAGER_WRITER_LOCKED );
42976 assert( pPager->eState!=PAGER_ERROR );
42977 assert( assert_pager_state(pPager) );
42991 assert( pPager->doNotSyncSpill==0 );
42992 pPager->doNotSyncSpill++;
43000 nPageCount = pPager->dbSize;
43015 if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
43016 if( pg!=PAGER_MJ_PGNO(pPager) ){
43017 rc = sqlite3PagerGet(pPager, pg, &pPage);
43026 }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
43043 PgHdr *pPage = pager_lookup(pPager, pg1+ii);
43051 assert( pPager->doNotSyncSpill==1 );
43052 pPager->doNotSyncSpill--;
43085 Pager *pPager = pPg->pPager;
43086 if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
43087 PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
43088 IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
43100 ** But this only happens if the pPager->changeCountDone flag is false.
43116 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
43119 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43120 || pPager->eState==PAGER_WRITER_DBMOD
43122 assert( assert_pager_state(pPager) );
43142 if( !pPager->changeCountDone && pPager->dbSize>0 ){
43145 assert( !pPager->tempFile && isOpen(pPager->fd) );
43148 rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
43167 assert( pPager->dbFileSize>0 );
43168 CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
43170 rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
43173 pPager->changeCountDone = 1;
43176 pPager->changeCountDone = 1;
43193 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
43195 if( !pPager->noSync ){
43197 rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
43198 }else if( isOpen(pPager->fd) ){
43200 sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC_OMITTED, (void *)&rc);
43216 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
43218 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43219 || pPager->eState==PAGER_WRITER_DBMOD
43220 || pPager->eState==PAGER_WRITER_LOCKED
43222 assert( assert_pager_state(pPager) );
43223 if( 0==pagerUseWal(pPager) ){
43224 rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
43230 ** Sync the database file for the pager pPager. zMaster points to the name
43256 Pager *pPager, /* Pager object */
43262 assert( pPager->eState==PAGER_WRITER_LOCKED
43263 || pPager->eState==PAGER_WRITER_CACHEMOD
43264 || pPager->eState==PAGER_WRITER_DBMOD
43265 || pPager->eState==PAGER_ERROR
43267 assert( assert_pager_state(pPager) );
43270 if( NEVER(pPager->errCode) ) return pPager->errCode;
43273 pPager->zFilename, zMaster, pPager->dbSize));
43276 if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
43283 sqlite3BackupRestart(pPager->pBackup);
43285 if( pagerUseWal(pPager) ){
43286 PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
43291 rc = sqlite3PagerGet(pPager, 1, &pPageOne);
43297 rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1,
43298 (pPager->fullSync ? pPager->syncFlags : 0)
43303 sqlite3PcacheCleanAll(pPager->pPCache);
43331 assert( isOpen(pPager->jfd)
43332 || pPager->journalMode==PAGER_JOURNALMODE_OFF
43333 || pPager->journalMode==PAGER_JOURNALMODE_WAL
43335 if( !zMaster && isOpen(pPager->jfd)
43336 && pPager->journalOff==jrnlBufferSize(pPager)
43337 && pPager->dbSize>=pPager->dbOrigSize
43338 && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
43346 rc = pager_incr_changecounter(pPager, 1);
43348 rc = sqlite3JournalCreate(pPager->jfd);
43350 rc = pager_incr_changecounter(pPager, 0);
43354 rc = pager_incr_changecounter(pPager, 0);
43369 if( pPager->dbSize<pPager->dbOrigSize
43370 && pPager->journalMode!=PAGER_JOURNALMODE_OFF
43373 const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
43374 const Pgno dbSize = pPager->dbSize; /* Database image size */
43375 pPager->dbSize = pPager->dbOrigSize;
43376 for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
43377 if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
43379 rc = sqlite3PagerGet(pPager, i, &pPage);
43386 pPager->dbSize = dbSize;
43394 rc = writeMasterJournal(pPager, zMaster);
43408 rc = syncJournal(pPager, 0);
43411 rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
43416 sqlite3PcacheCleanAll(pPager->pPCache);
43421 if( pPager->dbSize!=pPager->dbFileSize ){
43422 Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
43423 assert( pPager->eState==PAGER_WRITER_DBMOD );
43424 rc = pager_truncate(pPager, nNew);
43430 rc = sqlite3PagerSync(pPager);
43432 IOTRACE(("DBSYNC %p\n", pPager))
43437 if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
43438 pPager->eState = PAGER_WRITER_FINISHED;
43459 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
43465 if( NEVER(pPager->errCode) ) return pPager->errCode;
43467 assert( pPager->eState==PAGER_WRITER_LOCKED
43468 || pPager->eState==PAGER_WRITER_FINISHED
43469 || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
43471 assert( assert_pager_state(pPager) );
43484 if( pPager->eState==PAGER_WRITER_LOCKED
43485 && pPager->exclusiveMode
43486 && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
43488 assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
43489 pPager->eState = PAGER_READER;
43493 PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
43494 rc = pager_end_transaction(pPager, pPager->setMaster);
43495 return pager_error(pPager, rc);
43524 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
43526 PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
43532 assert( assert_pager_state(pPager) );
43533 if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
43534 if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
43536 if( pagerUseWal(pPager) ){
43538 rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
43539 rc2 = pager_end_transaction(pPager, pPager->setMaster);
43541 }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
43542 int eState = pPager->eState;
43543 rc = pager_end_transaction(pPager, 0);
43549 pPager->errCode = SQLITE_ABORT;
43550 pPager->eState = PAGER_ERROR;
43554 rc = pager_playback(pPager, 0);
43557 assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
43563 return pager_error(pPager, rc);
43570 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
43571 return pPager->readOnly;
43577 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
43578 return sqlite3PcacheRefCount(pPager->pPCache);
43585 SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
43586 int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
43588 return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
43589 + sqlite3MallocSize(pPager)
43590 + pPager->pageSize;
43604 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
43606 a[0] = sqlite3PcacheRefCount(pPager->pPCache);
43607 a[1] = sqlite3PcachePagecount(pPager->pPCache);
43608 a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
43609 a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
43610 a[4] = pPager->eState;
43611 a[5] = pPager->errCode;
43612 a[6] = pPager->nHit;
43613 a[7] = pPager->nMiss;
43614 a[8] = 0; /* Used to be pPager->nOvfl */
43615 a[9] = pPager->nRead;
43616 a[10] = pPager->nWrite;
43624 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
43638 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
43640 int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
43642 assert( pPager->eState>=PAGER_WRITER_LOCKED );
43643 assert( assert_pager_state(pPager) );
43645 if( nSavepoint>nCurrent && pPager->useJournal ){
43654 pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
43660 pPager->aSavepoint = aNew;
43664 aNew[ii].nOrig = pPager->dbSize;
43665 if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
43666 aNew[ii].iOffset = pPager->journalOff;
43668 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
43670 aNew[ii].iSubRec = pPager->nSubRec;
43671 aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
43675 if( pagerUseWal(pPager) ){
43676 sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
43678 pPager->nSavepoint = ii+1;
43680 assert( pPager->nSavepoint==nSavepoint );
43681 assertTruncateConstraint(pPager);
43717 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
43718 int rc = pPager->errCode; /* Return code */
43723 if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
43732 for(ii=nNew; ii<pPager->nSavepoint; ii++){
43733 sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
43735 pPager->nSavepoint = nNew;
43740 if( nNew==0 && isOpen(pPager->sjfd) ){
43742 if( sqlite3IsMemJournal(pPager->sjfd) ){
43743 rc = sqlite3OsTruncate(pPager->sjfd, 0);
43746 pPager->nSubRec = 0;
43754 else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
43755 PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
43756 rc = pagerPlaybackSavepoint(pPager, pSavepoint);
43767 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager){
43768 return pPager->zFilename;
43774 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
43775 return pPager->pVfs;
43783 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
43784 return pPager->fd;
43790 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
43791 return pPager->zJournal;
43798 SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
43799 return pPager->noSync;
43807 Pager *pPager,
43813 if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
43814 pPager->xCodec = pPager->memDb ? 0 : xCodec;
43815 pPager->xCodecSizeChng = xCodecSizeChng;
43816 pPager->xCodecFree = xCodecFree;
43817 pPager->pCodec = pCodec;
43818 pagerReportSize(pPager);
43820 SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){
43821 return pPager->pCodec;
43851 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
43858 assert( pPager->eState==PAGER_WRITER_CACHEMOD
43859 || pPager->eState==PAGER_WRITER_DBMOD
43861 assert( assert_pager_state(pPager) );
43897 PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
43898 IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
43909 assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
43919 pPgOld = pager_lookup(pPager, pgno);
43926 sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
43962 rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
43964 if( needSyncPgno<=pPager->dbOrigSize ){
43965 assert( pPager->pTmpSpace!=0 );
43966 sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
43983 assert( pPg->nRef>0 || pPg->pPager->memDb );
44005 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
44011 assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
44012 if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
44013 pPager->exclusiveMode = (u8)eMode;
44015 return (int)pPager->exclusiveMode;
44038 SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
44039 u8 eOld = pPager->journalMode; /* Prior journalmode */
44044 print_pager_state(pPager);
44060 assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
44075 assert( pPager->eState!=PAGER_ERROR );
44076 pPager->journalMode = (u8)eMode;
44089 assert( isOpen(pPager->fd) || pPager->exclusiveMode );
44090 if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
44100 sqlite3OsClose(pPager->jfd);
44101 if( pPager->eLock>=RESERVED_LOCK ){
44102 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
44105 int state = pPager->eState;
44108 rc = sqlite3PagerSharedLock(pPager);
44110 if( pPager->eState==PAGER_READER ){
44112 rc = pagerLockDb(pPager, RESERVED_LOCK);
44115 sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
44118 pagerUnlockDb(pPager, SHARED_LOCK);
44120 pager_unlock(pPager);
44122 assert( state==pPager->eState );
44128 return (int)pPager->journalMode;
44134 SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
44135 return (int)pPager->journalMode;
44143 SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
44144 assert( assert_pager_state(pPager) );
44145 if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
44146 if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
44156 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
44158 pPager->journalSizeLimit = iLimit;
44159 sqlite3WalLimit(pPager->pWal, iLimit);
44161 return pPager->journalSizeLimit;
44165 ** Return a pointer to the pPager->pBackup variable. The backup module
44170 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
44171 return &pPager->pBackup;
44182 SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
44184 if( pPager->pWal ){
44185 rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
44186 pPager->xBusyHandler, pPager->pBusyHandlerArg,
44187 pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
44194 SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
44195 return sqlite3WalCallback(pPager->pWal);
44202 SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
44203 const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
44204 return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
44211 static int pagerExclusiveLock(Pager *pPager){
44214 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
44215 rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
44219 pagerUnlockDb(pPager, SHARED_LOCK);
44231 static int pagerOpenWal(Pager *pPager){
44234 assert( pPager->pWal==0 && pPager->tempFile==0 );
44235 assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK || pPager->noReadlock);
44242 if( pPager->exclusiveMode ){
44243 rc = pagerExclusiveLock(pPager);
44250 rc = sqlite3WalOpen(pPager->pVfs,
44251 pPager->fd, pPager->zWal, pPager->exclusiveMode,
44252 pPager->journalSizeLimit, &pPager->pWal
44276 Pager *pPager, /* Pager object */
44281 assert( assert_pager_state(pPager) );
44282 assert( pPager->eState==PAGER_OPEN || pbOpen );
44283 assert( pPager->eState==PAGER_READER || !pbOpen );
44285 assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
44287 if( !pPager->tempFile && !pPager->pWal ){
44288 if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
44291 sqlite3OsClose(pPager->jfd);
44293 rc = pagerOpenWal(pPager);
44295 pPager->journalMode = PAGER_JOURNALMODE_WAL;
44296 pPager->eState = PAGER_OPEN;
44314 SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager){
44317 assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
44323 if( !pPager->pWal ){
44325 rc = pagerLockDb(pPager, SHARED_LOCK);
44328 pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
44332 rc = pagerOpenWal(pPager);
44339 if( rc==SQLITE_OK && pPager->pWal ){
44340 rc = pagerExclusiveLock(pPager);
44342 rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
44343 pPager->pageSize, (u8*)pPager->pTmpSpace);
44344 pPager->pWal = 0;
44360 CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
47722 ** global SQLITE_MUTEX_STATIC_MASTER mutex. The pPager field
47746 Pager *pPager; /* The page cache */
47970 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
49043 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
49086 rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
49345 temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
49817 rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
49831 pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
50041 if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
50042 && sqlite3PagerVfs(pBt->pPager)==pVfs ){
50091 rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
50094 rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
50101 sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
50106 pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager);
50135 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
50198 if( pBt && pBt->pPager ){
50199 sqlite3PagerClose(pBt->pPager);
50210 sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
50316 sqlite3PagerClose(pBt->pPager);
50355 sqlite3PagerSetCachesize(pBt->pPager, mxPage);
50379 sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync);
50394 assert( pBt && pBt->pPager );
50395 rc = sqlite3PagerNosync(pBt->pPager);
50440 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
50476 n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
50564 rc = sqlite3PagerSharedLock(pBt->pPager);
50573 sqlite3PagerPagecount(pBt->pPager, &nPageFile);
50611 rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
50650 rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
50710 assert( sqlite3PagerRefcount(pBt->pPager)==1 );
50862 rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
50921 rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
51056 Pager *pPager = pBt->pPager;
51067 rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
51235 sqlite3PagerTruncateImage(pBt->pPager, iLastPg);
51280 Pager *pPager = pBt->pPager;
51281 VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
51323 sqlite3PagerTruncateImage(pBt->pPager, nFin);
51327 sqlite3PagerRollback(pPager);
51331 assert( nRef==sqlite3PagerRefcount(pPager) );
51379 rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
51462 rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
51577 rc2 = sqlite3PagerRollback(pBt->pPager);
51588 if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
51634 rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
51658 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
52202 rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
55699 return p->pBt->pPager;
55809 if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
56114 nRef = sqlite3PagerRefcount(pBt->pPager);
56116 sCheck.pPager = pBt->pPager;
56183 if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
56186 nRef, sqlite3PagerRefcount(pBt->pPager)
56212 assert( p->pBt->pPager!=0 );
56213 return sqlite3PagerFilename(p->pBt->pPager);
56225 assert( p->pBt->pPager!=0 );
56226 return sqlite3PagerJournalname(p->pBt->pPager);
56254 rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
64032 Pager *pPager; /* Pager associated with pBt */
64035 const char *zFilename; /* Name of database file for pPager */
69074 Pager *pPager; /* Pager associated with pBt */
69077 const char *zFilename; /* Name of database file for pPager */
69092 u.ch.pPager = sqlite3BtreePager(u.ch.pBt);
69093 u.ch.eOld = sqlite3PagerGetJournalMode(u.ch.pPager);
69095 if( !sqlite3PagerOkToChangeJournalMode(u.ch.pPager) ) u.ch.eNew = u.ch.eOld;
69098 u.ch.zFilename = sqlite3PagerFilename(u.ch.pPager);
69105 || !sqlite3PagerWalSupported(u.ch.pPager)) /* No shared-memory support */
69128 rc = sqlite3PagerCloseWal(u.ch.pPager);
69130 sqlite3PagerSetJournalMode(u.ch.pPager, u.ch.eNew);
69135 sqlite3PagerSetJournalMode(u.ch.pPager, PAGER_JOURNALMODE_OFF);
69152 u.ch.eNew = sqlite3PagerSetJournalMode(u.ch.pPager, u.ch.eNew);
78474 Pager *pPager;
78483 pPager = sqlite3BtreePager(aNew->pBt);
78484 sqlite3PagerLockingMode(pPager, db->dfltLockMode);
90454 Pager *pPager;
90467 pPager = sqlite3BtreePager(db->aDb[ii].pBt);
90468 sqlite3PagerLockingMode(pPager, eMode);
90472 pPager = sqlite3BtreePager(pDb->pBt);
90473 eMode = sqlite3PagerLockingMode(pPager, eMode);
90541 Pager *pPager = sqlite3BtreePager(pDb->pBt);
90547 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
90748 Pager *pPager = sqlite3BtreePager(pDb->pBt);
90750 sqlite3_file *pFile = sqlite3PagerFile(pPager);
90762 Pager *pPager = sqlite3BtreePager(pDb->pBt);
90763 sqlite3_file *pFile = sqlite3PagerFile(pPager);
91409 Pager *pPager;
91415 if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
112821 Pager *pPager;
112824 pPager = sqlite3BtreePager(pBtree);
112825 assert( pPager!=0 );
112826 fd = sqlite3PagerFile(pPager);