Lines Matching full:pager
4412 ** CAPI3REF: Enable Or Disable Shared Pager Cache
6685 ** callback for the database handle. Each pager opened via the sqlite
6687 ** callback is currently invoked only from within pager.c.
6890 ** pager.h.
7003 SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);
7483 /************** Include pager.h in the middle of sqliteInt.h *****************/
7484 /************** Begin file pager.h *******************************************/
7520 ** Each open file is managed by a separate instance of the "Pager" structure.
7522 typedef struct Pager Pager;
7534 ** roll back. See comments for function writeMasterJournal() in pager.c
7566 ** that make up the Pager sub-system API. See source code comments for
7570 /* Open and close a Pager connection. */
7573 Pager **ppPager,
7580 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
7581 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*);
7583 /* Functions used to configure a Pager object. */
7584 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
7585 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u16*, int);
7586 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int);
7587 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
7588 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int);
7589 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int);
7590 SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *, int);
7591 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64);
7592 Pager*);
7595 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
7597 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
7604 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
7609 /* Functions used to manage pager transactions and savepoints. */
7610 SQLITE_PRIVATE int sqlite3PagerPagecount(Pager*, int*);
7611 SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int);
7612 SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
7613 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
7614 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*);
7615 SQLITE_PRIVATE int sqlite3PagerRollback(Pager*);
7616 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
7617 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
7618 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
7620 /* Functions used to query pager state and configuration. */
7621 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
7622 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*);
7623 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*);
7624 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*);
7625 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*);
7626 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*);
7627 SQLITE_PRIVATE int sqlite3PagerNosync(Pager*);
7628 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
7629 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*);
7632 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
7640 SQLITE_PRIVATE int *sqlite3PagerStats(Pager*);
7641 SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
7651 /************** End of pager.h ***********************************************/
7684 Pager *pPager; /* The pager this page is part of */
7718 /* Create a new pager cache.
7787 /* Set and get the suggested cache-size for the specified pager-cache.
7790 ** the total number of pages cached by purgeable pager-caches to the sum
8020 ** actual data in the bytes used for locking. The pager never allocates
24687 /* The pager calls this method to signal that it has done
30390 ** global pcache mutex and unlock the pager-cache object pCache. This is
30393 ** reclaim memory from this pager-cache.
30960 ** held by the pager system. Memory in use by any SQLite pager allocated
31432 /************** Begin file pager.c *******************************************/
31444 ** This is the implementation of the page cache subsystem or "pager".
31446 ** The pager is used to access a database disk file. It implements
31448 ** is separate from the database file. The pager also implements file
31470 ** PAGERID() takes a pointer to a Pager struct as its argument. The
31503 ** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE
31516 ** called on an outstanding page which means that the pager must
31556 ** are stored in the Pager.aSavepoint[] array, which is allocated and
31580 ** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
31582 ** and is returned as the result of every major pager API call. The
31584 ** next successful rollback is performed on the pager cache. Also,
31591 ** The variable Pager.dbSize contains the number of pages that the database
31593 ** variable is updated. The variable Pager.dbFileSize contains the number
31594 ** of pages in the database file. This may be different from Pager.dbSize
31597 ** truncated by an incremental-vacuum operation. The Pager.dbOrigSize variable
31600 ** only guaranteed to be correct if the boolean Pager.dbSizeValid is true.
31646 ** may be written into the journal file while the pager is still in
31669 ** sub-journals are only used for in-memory pager files.
31671 struct Pager {
31686 ** are either constant throughout the lifetime of the pager, or else
31687 ** used to store configuration parameters that affect the way the pager
31742 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
31798 ** The journal header size for this pager. This is usually the same
31826 static int assert_pager_state(Pager *pPager){
31849 Pager *pPager = pPg->pPager;
31924 ** can be used with this pager. The optimization can be used if:
31940 static int jrnlBufferSize(Pager *pPager){
31994 Pager *pPager = pPg->pPager;
32006 ** When this is called the journal file for pager pPager must be open.
32075 ** Pager.journalOff Return value
32083 static i64 journalHdrOffset(Pager *pPager){
32099 ** within the current transaction (i.e. if Pager.journalOff==0).
32101 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
32104 ** if the pager is not in no-sync mode, sync the journal file immediately
32107 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
32110 ** journal file to Pager.journalSizeLimit bytes. The journal file does
32116 static int zeroJournalHdr(Pager *pPager, int doTruncate){
32165 static int writeJournalHdr(Pager *pPager){
32204 ** * When the pager is in no-sync mode. Corruption can follow a
32241 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
32252 ** database page size. Since the zHeader buffer is only Pager.pageSize
32283 Pager *pPager, /* Pager object */
32295 /* Advance Pager.journalOff to the start of the next sector. If the
32373 ** of Pager.sectorSize is restored at the end of that routine.
32384 ** Write the supplied master journal name into the journal file for pager
32386 ** thing written to a journal file. If the pager is in full-sync mode, the
32402 static int writeMasterJournal(Pager *pPager, const char *zMaster){
32446 /* If the pager is in peristent-journal mode, then the physical
32469 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
32480 ** Unless the pager is in error-state, discard all in-memory pages. If
32481 ** the pager is in error-state, then this call is a no-op.
32483 ** TODO: Why can we not reset the pager while in error state?
32485 static void pager_reset(Pager *pPager){
32494 ** Free all structures in the Pager.aSavepoint[] array and set both
32495 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
32496 ** if it is open and the pager is not in exclusive mode.
32498 static void releaseAllSavepoints(Pager *pPager){
32499 int ii; /* Iterator for looping through Pager.aSavepoint */
32517 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
32533 ** Unlock the database file. This function is a no-op if the pager
32536 ** If the pager is currently in error state, discard the contents of
32537 ** the cache and reset the Pager structure internal state. If there is
32539 ** on the pager file (by this or any other process), it will be
32542 static void pager_unlock(Pager *pPager){
32556 ** values stored in Pager.dbSize etc. might become invalid if
32568 /* If Pager.errCode is set, the contents of the pager cache cannot be
32569 ** trusted. Now that the pager file is unlocked, the contents of the
32587 ** may have occurred. The first argument is a pointer to the pager
32588 ** structure, the second the error-code about to be returned by a pager
32594 ** subsequent API calls on this Pager will immediately return the same
32597 ** A persistent error indicates that the contents of the pager-cache
32599 ** the contents of the pager-cache. If a transaction was active when
32604 static int pager_error(Pager *pPager, int rc){
32622 ** If the pager has already entered the error state, do not attempt
32627 ** to obtain a shared lock on the pager (which may be this one) will
32630 ** If the pager has not already entered the error state, but an IO or
32632 ** the pager to enter the error state. Which will be cleared by the
32635 static void pagerUnlockAndRollback(Pager *pPager){
32651 ** If the pager is in PAGER_SHARED or PAGER_UNLOCK state when this
32660 ** depends on whether or not the pager is running in exclusive mode and
32661 ** the current journal-mode (Pager.journalMode value), as follows:
32678 ** If the pager is running in exclusive mode, this method of finalizing
32680 ** DELETE and the pager is in exclusive mode, the method described under
32684 ** pager moves to PAGER_SHARED state (and downgrades the lock on the
32687 ** If the pager is running in exclusive mode and is in PAGER_SYNCED state,
32700 static int pager_end_transaction(Pager *pPager, int hasMaster){
32732 /* This branch may be executed with Pager.journalMode==MEMORY if
32796 static u32 pager_cksum(Pager *pPager, const u8 *aData){
32817 ** is greater than the current value of Pager.dbSize, then playback is
32845 Pager *pPager, /* The pager being played back */
32903 /* If the pager is in RESERVED state, then there must be a copy of this
32904 ** page in the pager cache. In this case just update the pager cache,
32909 ** not be in the pager cache. Later: if a malloc() or IO error occurs
32914 ** If in EXCLUSIVE state, then we update the pager cache if it exists
32970 ** and if the pager requires a journal-sync, then mark the page as
33002 ** already in the journal file (recorded in Pager.pInJournal) and
33015 /* If this was page 1, then restore the value of Pager.dbFileVers.
33034 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
33071 static int pager_delmaster(Pager *pPager, const char *zMaster){
33183 static int pager_truncate(Pager *pPager, Pgno nPage){
33187 /* TODO: Is it safe to use Pager.dbFileSize here? */
33205 ** Set the value of the Pager.sectorSize variable for the given
33206 ** pager based on the value returned by the xSectorSize method
33218 static void setSectorSize(Pager *pPager){
33290 ** If the journal really is hot, reset the pager cache prior rolling
33294 static int pager_playback(Pager *pPager, int isHot){
33320 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
33414 ** code. This will cause the pager to enter the error state
33468 /* The Pager.sectorSize variable may have been updated while rolling
33507 ** In either case, before playback commences the Pager.dbSize variable
33512 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
33611 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
33642 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
33675 Pager *pPager, /* The pager object */
33695 ** The pager
33711 ** returned to the caller of the pager API function.
33714 Pager *pPager, /* Pager object */
33727 static void pagerReportSize(Pager *pPager){
33738 ** Change the page size used by the Pager object. The new page size
33741 ** If the pager is in the error state when this function is called, it
33755 ** then the pager object page size is set to *pPageSize.
33758 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
33763 ** conditions above is not true, the pager was in error state when this
33767 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize, int nReserve){
33799 ** by the pager. This is a buffer that is big enough to hold the
33805 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
33816 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
33852 ** If the pager was opened on a transient file (zFilename==""), or
33862 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
33882 ** If the pager is in error state when this function is called, then the
33891 SQLITE_PRIVATE int sqlite3PagerPagecount(Pager *pPager, int *pnPage){
33894 /* If the pager is already in the error state, return the error code. */
33924 ** configured maximum pager number, increase the allowed limit so
33950 ** the lock. If the lock is obtained successfully, set the Pager.state
33953 static int pager_wait_on_lock(Pager *pPager, int locktype){
33956 /* The OS lock values must be the same as the Pager lock values */
34018 static void assertTruncateConstraint(Pager *pPager){
34028 ** just sets the internal state of the pager object so that the
34031 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
34053 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
34062 /* Set Pager.journalHdr to -1 for the benefit of the pager_playback()
34111 ** If the Pager.needSync flag is not set, then this function is a
34121 ** been written following it. If the pager is operating in full-sync
34137 ** The Pager.needSync flag is never be set for temporary files, or any
34138 ** file operating in no-sync mode (Pager.noSync set to non-zero).
34144 static int syncJournal(Pager *pPager){
34156 ** than Pager.journalOff bytes. If the next thing in the journal
34167 ** a valid header following Pager.journalOff, then write a 0x00
34225 /* The journal file was just successfully synced. Set Pager.needSync
34243 ** The pager must hold at least a RESERVED lock when this function
34248 ** If the pager is a temp-file pager and the actual file-system file
34256 ** * The page number is greater than Pager.dbSize, or
34259 ** If writing out a page causes the database file to grow, Pager.dbFileSize
34261 ** in Pager.dbFileVers[] is updated to match the new value stored in
34269 Pager *pPager; /* Pager object */
34285 ** While the pager is in the RESERVED state, the original database file
34307 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
34326 /* If page 1 was just written, update Pager.dbFileVers to match
34337 /* Update any backup objects copying the contents of this pager. */
34372 Pager *pPager = pPg->pPager;
34398 ** soft memory limit. The first argument is a pointer to a Pager object
34399 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
34402 ** is always associated with the Pager object passed as the first
34416 Pager *pPager = (Pager *)p;
34432 ** Similarly, if the pager has already entered the error state, do not
34503 ** Allocate and initialize a new Pager object and put a pointer to it
34504 ** in *ppPager. The pager should eventually be freed by passing it
34519 ** operation of the pager. It should be passed some bitwise combination
34525 ** If the pager object is allocated and the specified file opened
34527 ** the new pager object. If an error occurs, *ppPager is set to NULL
34534 Pager **ppPager, /* OUT: Return the Pager structure here */
34542 Pager *pPager = 0; /* Pager
34609 /* Allocate memory for the Pager structure, PCache object, the
34613 ** Pager object (sizeof(Pager) bytes)
34622 ROUND8(sizeof(*pPager)) + /* Pager structure */
34634 pPager = (Pager*)(pPtr);
34642 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
34654 /* Open the pager file.
34709 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
34718 ** Pager structure and close the file.
34787 ** the file-system for the given pager. A hot journal is one that
34815 static int hasHotJournal(Pager *pPager, int *pExists){
34901 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
34908 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
34949 ** 1) If the pager is currently in PAGER_UNLOCK state (no lock held
34958 ** 2) If the pager is running in exclusive-mode, and there are currently
34965 ** pager is in an error state other than SQLITE_FULL when this is called,
34973 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
34983 ** the error. Discard the contents of the pager-cache and rollback
35067 ** may mean that the pager was in the error-state when this
35153 ** transaction and unlock the pager.
35159 static void pagerUnlockIfUnused(Pager *pPager){
35168 ** Acquire a reference to page number pgno in pager pPager (a page
35200 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
35218 Pager *pPager, /* The pager open on the database file */
35233 /* If the pager is in the error state, return an error immediately.
35243 ** pager was already in the error-state when this function was called.
35259 /* The pager cache has created a new page. Its content needs to
35331 ** pager is in PAGER_UNLOCK state when this function is called,
35332 ** or if the pager is in an error state other than SQLITE_FULL.
35340 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
35360 Pager *pPager = pPg->pPager;
35375 static int openSubJournal(Pager *pPager){
35392 ** Open the journal file for pager pPager and write a journal header
35403 ** Pager.pInJournal bitvec structure is allocated.
35406 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
35409 static int pager_open_journal(Pager *pPager){
35483 ** Begin a write-transaction on the specified pager object. If a
35507 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
35535 /* This happens when the pager was in exclusive-access mode the last
35552 ** purpose of this call is to reset the internal state of the pager
35565 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
35570 Pager *pPager = pPg->pPager;
35727 Pager *pPager = pPg->pPager;
35824 ** A call to this routine tells the pager that it is not necessary to
35831 ** on the given page is unused. The pager marks the page as clean so
35838 Pager *pPager = pPg->pPager;
35853 ** byte offset 24 of the pager file.
35866 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
35933 ** Sync the pager file to disk. This is a no-op for in-memory files
35934 ** or pages with the Pager.noSync flag set.
35936 ** If successful, or called on a pager for which it is a no-op, this
35939 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
35951 ** Sync the database file for the pager pPager. zMaster points to the name
35977 Pager *pPager, /* Pager object */
36056 ** current value of Pager.dbSize, set dbSize back to the value
36144 ** If an error occurs, an IO error code is returned and the pager
36147 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
36155 /* This function should not be called if the pager is not in at least
36162 ** this transaction, the pager is running in exclusive-mode and is
36169 ** header. Since the pager is in exclusive mode, there is no need
36207 ** * If the pager is in PAGER_RESERVED state, then attempt (1). Whether
36214 ** (operation 1) failed. However the pager must enter the error state
36228 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
36254 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
36267 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
36272 ** Return the number of references to the pager.
36274 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
36289 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
36307 ** Return true if this is an in-memory pager.
36309 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
36323 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
36329 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
36336 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
36386 ** (the first created). A value of (Pager.nSavepoint-1) means operate
36388 ** (Pager.nSavepoint-1), then this function is a no-op.
36404 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
36453 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager){
36458 ** Return the VFS structure for the pager.
36460 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
36466 ** with the pager. This might return NULL if the file has
36469 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
36476 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
36481 ** Return true if fsync() calls are disabled for this pager. Return FALSE
36484 SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
36490 ** Set or retrieve the codec for this pager
36493 Pager *pPager,
36506 static void *sqlite3PagerGetCodec(Pager *pPager){
36537 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
36626 ** loading the page into the pager-cache and setting the PgHdr.needSync
36637 ** sure the Pager.needSync flag is set too.
36679 ** Return a pointer to the Pager.nExtra bytes of "extra" space
36687 ** Get/set the locking-mode for this pager. Parameter eMode must be one
36696 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
36709 ** Get/set the journal-mode for this pager. Parameter eMode must be one of:
36729 SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *pPager, int eMode){
36757 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
36770 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
36776 /************** End of pager.c ***********************************************/
37087 DbPage *pDbPage; /* Pager page handle */
37199 Pager *pPager; /* The page cache */
37418 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
37833 ** Enable or disable the shared pager and schema features.
38317 ** page from the pager layer with the 'no-content' flag set. True otherwise.
39285 ** Convert a DbPage obtained from the pager into a MemPage used by
39299 ** Get a page from the pager. Initialize the MemPage.pBt and
39326 ** Retrieve a page from the pager cache. If the requested page is not
39327 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
39354 ** Get a page from the pager and initialize it. This routine is just a
39405 ** During a rollback, when the pager reloads information into the cache
39808 ** value of mxPage. If mxPage is negative, the pager will
40306 /* This call makes sure that the pager has the correct number of
40444 Pager *pPager = pBt->pPager;
40663 Pager *pPager = pBt->pPager;
40786 ** call below will unlock the pager. */
40796 ** pager if this call closed the only read or write transaction. */
40997 /* At the pager level, a statement transaction is a savepoint with
41051 ** 2: Other database connections that share the same pager cache
44991 ** Return the pager associated with a BTree. This routine is used for
44994 SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){
45503 ** The pager filename is invariant as long as the pager is
45516 ** The pager journal filename is invariant as long as the pager is
45726 int isAttached; /* True once backup has been registered with pager */
45727 sqlite3_backup *pNext; /* Next backup associated with source pager */
45742 ** invoked by the pager layer to report various state changes in
45884 Pager * const pDestPager = sqlite3BtreePager(p->pDest);
45922 ** and the pager code use this trick (clearing the first byte
45954 ** Register this backup object with the associated source pager for
45980 Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
45981 Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
45986 /* If the source pager is currently in a write-transaction, return
46013 ** source pager for the number of pages in the database.
46169 /* Detach this backup from the source pager. */
46234 ** has been modified by a transaction on the source pager. Copy
46247 ** Restart the backup process. This is called when the pager layer
52967 Pager *pPager;
55240 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
55271 ** P2==2 is the database format. P2==3 is the recommended pager cache
58129 Pager *pPager;
65817 Pager *pPager;
77328 ** buffer that the pager module resizes using sqlite3_realloc().
77390 Pager *pPager;
77448 Pager *pPager;
77490 Pager *pPager = sqlite3BtreePager(pDb->pBt);
77697 Pager *pPager = sqlite3BtreePager(pDb->pBt);
77711 Pager *pPager = sqlite3BtreePager(pDb->pBt);
78292 Pager *pPager;
85605 ** An optimisation would be to use a non-journaled pager.
85784 ** vacuum database. The vacuum_db journal file is deleted when the pager
96023 ** at the b-tree/pager level.
96629 ** a temporary file for transient pager files and statement journals.
96704 /* If the B-Tree was successfully opened, set the pager-cache size to the
96706 ** open on an existing shared pager-cache, do not change the pager-cache
97111 ** database it is 'NONE'. This matches the pager layer defaults.
97582 Pager *pPager;
