Lines Matching full:pager
4412 ** CAPI3REF: Enable Or Disable Shared Pager Cache
6690 ** callback for the database handle. Each pager opened via the sqlite
6692 ** callback is currently invoked only from within pager.c.
6895 ** pager.h.
7008 SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);
7488 /************** Include pager.h in the middle of sqliteInt.h *****************/
7489 /************** Begin file pager.h *******************************************/
7525 ** Each open file is managed by a separate instance of the "Pager" structure.
7527 typedef struct Pager Pager;
7539 ** roll back. See comments for function writeMasterJournal() in pager.c
7571 ** that make up the Pager sub-system API. See source code comments for
7575 /* Open and close a Pager connection. */
7578 Pager **ppPager,
7585 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
7586 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*);
7588 /* Functions used to configure a Pager object. */
7589 SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
7590 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u16*, int);
7591 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int);
7592 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
7593 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int);
7594 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int);
7595 Pager *, int);
7596 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64);
7597 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*);
7600 SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
7602 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
7609 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
7614 /* Functions used to manage pager transactions and savepoints. */
7615 SQLITE_PRIVATE int sqlite3PagerPagecount(Pager*, int*);
7616 SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int);
7617 SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
7618 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
7619 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*);
7620 SQLITE_PRIVATE int sqlite3PagerRollback(Pager*);
7621 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
7622 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
7623 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
7625 /* Functions used to query pager state and configuration. */
7626 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
7627 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*);
7628 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*);
7629 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*);
7630 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*);
7631 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*);
7632 SQLITE_PRIVATE int sqlite3PagerNosync(Pager*);
7633 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
7634 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*);
7637 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
7645 SQLITE_PRIVATE int *sqlite3PagerStats(Pager*);
7646 SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
7656 /************** End of pager.h ***********************************************/
7689 Pager *pPager; /* The pager this page is part of */
7723 /* Create a new pager cache.
7792 /* Set and get the suggested cache-size for the specified pager-cache.
7795 ** the total number of pages cached by purgeable pager-caches to the sum
8025 ** actual data in the bytes used for locking. The pager never allocates
24692 /* The pager calls this method to signal that it has done
30395 ** global pcache mutex and unlock the pager-cache object pCache. This is
30398 ** reclaim memory from this pager-cache.
30965 ** held by the pager system. Memory in use by any SQLite pager allocated
31437 /************** Begin file pager.c *******************************************/
31449 ** This is the implementation of the page cache subsystem or "pager".
31451 ** The pager is used to access a database disk file. It implements
31453 ** is separate from the database file. The pager also implements file
31475 ** PAGERID() takes a pointer to a Pager struct as its argument. The
31508 ** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE
31521 ** called on an outstanding page which means that the pager must
31561 ** are stored in the Pager.aSavepoint[] array, which is allocated and
31585 ** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
31587 ** and is returned as the result of every major pager API call. The
31589 ** next successful rollback is performed on the pager cache. Also,
31596 ** The variable Pager.dbSize contains the number of pages that the database
31598 ** variable is updated. The variable Pager.dbFileSize contains the number
31599 ** of pages in the database file. This may be different from Pager.dbSize
31602 ** truncated by an incremental-vacuum operation. The Pager.dbOrigSize variable
31605 ** only guaranteed to be correct if the boolean Pager.dbSizeValid is true.
31651 ** may be written into the journal file while the pager is still in
31674 ** sub-journals are only used for in-memory pager files.
31676 struct Pager {
31691 ** are either constant throughout the lifetime of the pager, or else
31692 ** used to store configuration parameters that affect the way the pager
31747 char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
31803 ** The journal header size for this pager. This is usually the same
31831 static int assert_pager_state(Pager *pPager){
31854 Pager *pPager = pPg->pPager;
31929 ** can be used with this pager. The optimization can be used if:
31945 static int jrnlBufferSize(Pager *pPager){
31999 Pager *pPager = pPg->pPager;
32011 ** When this is called the journal file for pager pPager must be open.
32080 ** Pager.journalOff Return value
32088 static i64 journalHdrOffset(Pager *pPager){
32104 ** within the current transaction (i.e. if Pager.journalOff==0).
32106 ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
32109 ** if the pager is not in no-sync mode, sync the journal file immediately
32112 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
32115 ** journal file to Pager.journalSizeLimit bytes. The journal file does
32121 static int zeroJournalHdr(Pager *pPager, int doTruncate){
32170 static int writeJournalHdr(Pager *pPager){
32209 ** * When the pager is in no-sync mode. Corruption can follow a
32246 ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
32257 ** database page size. Since the zHeader buffer is only Pager.pageSize
32288 Pager *pPager, /* Pager object */
32300 /* Advance Pager.journalOff to the start of the next sector. If the
32378 ** of Pager.sectorSize is restored at the end of that routine.
32389 ** Write the supplied master journal name into the journal file for pager
32391 ** thing written to a journal file. If the pager is in full-sync mode, the
32407 static int writeMasterJournal(Pager *pPager, const char *zMaster){
32451 /* If the pager is in peristent-journal mode, then the physical
32474 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
32485 ** Unless the pager is in error-state, discard all in-memory pages. If
32486 ** the pager is in error-state, then this call is a no-op.
32488 ** TODO: Why can we not reset the pager while in error state?
32490 static void pager_reset(Pager *pPager){
32499 ** Free all structures in the Pager.aSavepoint[] array and set both
32500 ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
32501 ** if it is open and the pager is not in exclusive mode.
32503 static void releaseAllSavepoints(Pager *pPager){
32504 int ii; /* Iterator for looping through Pager.aSavepoint */
32522 static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
32538 ** Unlock the database file. This function is a no-op if the pager
32541 ** If the pager is currently in error state, discard the contents of
32542 ** the cache and reset the Pager structure internal state. If there is
32544 ** on the pager file (by this or any other process), it will be
32547 static void pager_unlock(Pager *pPager){
32561 ** values stored in Pager.dbSize etc. might become invalid if
32573 /* If Pager.errCode is set, the contents of the pager cache cannot be
32574 ** trusted. Now that the pager file is unlocked, the contents of the
32592 ** may have occurred. The first argument is a pointer to the pager
32593 ** structure, the second the error-code about to be returned by a pager
32599 ** subsequent API calls on this Pager will immediately return the same
32602 ** A persistent error indicates that the contents of the pager-cache
32604 ** the contents of the pager-cache. If a transaction was active when
32609 static int pager_error(Pager *pPager, int rc){
32627 ** If the pager has already entered the error state, do not attempt
32632 ** to obtain a shared lock on the pager (which may be this one) will
32635 ** If the pager has not already entered the error state, but an IO or
32637 ** the pager to enter the error state. Which will be cleared by the
32640 static void pagerUnlockAndRollback(Pager *pPager){
32656 ** If the pager is in PAGER_SHARED or PAGER_UNLOCK state when this
32665 ** depends on whether or not the pager is running in exclusive mode and
32666 ** the current journal-mode (Pager.journalMode value), as follows:
32683 ** If the pager is running in exclusive mode, this method of finalizing
32685 ** DELETE and the pager is in exclusive mode, the method described under
32689 ** pager moves to PAGER_SHARED state (and downgrades the lock on the
32692 ** If the pager is running in exclusive mode and is in PAGER_SYNCED state,
32705 static int pager_end_transaction(Pager *pPager, int hasMaster){
32737 /* This branch may be executed with Pager.journalMode==MEMORY if
32801 static u32 pager_cksum(Pager *pPager, const u8 *aData){
32822 ** is greater than the current value of Pager.dbSize, then playback is
32850 Pager *pPager, /* The pager being played back */
32908 /* If the pager is in RESERVED state, then there must be a copy of this
32909 ** page in the pager cache. In this case just update the pager cache,
32914 ** not be in the pager cache. Later: if a malloc() or IO error occurs
32919 ** If in EXCLUSIVE state, then we update the pager cache if it exists
32975 ** and if the pager requires a journal-sync, then mark the page as
33007 ** already in the journal file (recorded in Pager.pInJournal) and
33020 /* If this was page 1, then restore the value of Pager.dbFileVers.
33039 ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
33076 static int pager_delmaster(Pager *pPager, const char *zMaster){
33188 static int pager_truncate(Pager *pPager, Pgno nPage){
33192 /* TODO: Is it safe to use Pager.dbFileSize here? */
33210 ** Set the value of the Pager.sectorSize variable for the given
33211 ** pager based on the value returned by the xSectorSize method
33223 static void setSectorSize(Pager *pPager){
33295 ** If the journal really is hot, reset the pager cache prior rolling
33299 static int pager_playback(Pager *pPager, int isHot){
33325 ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
33419 ** code. This will cause the pager to enter the error state
33473 /* The Pager.sectorSize variable may have been updated while rolling
33512 ** In either case, before playback commences the Pager.dbSize variable
33517 static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
33616 SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
33647 SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
33680 Pager *pPager, /* The pager object */
33700 ** The pager invokes the busy-handler if sqlite3OsLock() returns
33716 ** returned to the caller of the pager API function.
33719 Pager *pPager, /* Pager object */
33732 static void pagerReportSize(Pager *pPager){
33743 ** Change the page size used by the Pager object. The new page size
33746 ** If the pager is in the error state when this function is called, it
33760 ** then the pager object page size is set to *pPageSize.
33763 ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
33768 ** conditions above is not true, the pager was in error state when this
33772 SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize, int nReserve){
33804 ** by the pager. This is a buffer that is big enough to hold the
33810 SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
33821 SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
33857 ** If the pager was opened on a transient file (zFilename==""), or
33867 SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
33887 ** If the pager is in error state when this function is called, then the
33896 SQLITE_PRIVATE int sqlite3PagerPagecount(Pager *pPager, int *pnPage){
33899 /* If the pager is already in the error state, return the error code. */
33929 ** configured maximum pager number, increase the allowed limit so
33955 ** the lock. If the lock is obtained successfully, set the Pager.state
33958 static int pager_wait_on_lock(Pager *pPager, int locktype){
33961 /* The OS lock values must be the same as the Pager lock values */
34023 static void assertTruncateConstraint(Pager *pPager){
34033 ** just sets the internal state of the pager object so that the
34036 SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
34058 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
34067 /* Set Pager.journalHdr to -1 for the benefit of the pager_playback()
34116 ** If the Pager.needSync flag is not set, then this function is a
34126 ** been written following it. If the pager is operating in full-sync
34142 ** The Pager.needSync flag is never be set for temporary files, or any
34143 ** file operating in no-sync mode (Pager.noSync set to non-zero).
34149 static int syncJournal(Pager *pPager){
34161 ** than Pager.journalOff bytes. If the next thing in the journal
34172 ** a valid header following Pager.journalOff, then write a 0x00
34230 /* The journal file was just successfully synced. Set Pager.needSync
34248 ** The pager must hold at least a RESERVED lock when this function
34253 ** If the pager is a temp-file pager and the actual file-system file
34261 ** * The page number is greater than Pager.dbSize, or
34264 ** If writing out a page causes the database file to grow, Pager.dbFileSize
34266 ** in Pager.dbFileVers[] is updated to match the new value stored in
34274 Pager *pPager; /* Pager object */
34290 ** While the pager is in the RESERVED state, the original database file
34312 ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
34331 /* If page 1 was just written, update Pager.dbFileVers to match
34342 /* Update any backup objects copying the contents of this pager. */
34377 Pager *pPager = pPg->pPager;
34403 ** soft memory limit. The first argument is a pointer to a Pager object
34404 ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
34407 ** is always associated with the Pager object passed as the first
34421 Pager *pPager = (Pager *)p;
34437 ** Similarly, if the pager has already entered the error state, do not
34508 ** Allocate and initialize a new Pager object and put a pointer to it
34509 ** in *ppPager. The pager should eventually be freed by passing it
34524 ** operation of the pager. It should be passed some bitwise combination
34530 ** If the pager object is allocated and the specified file opened
34532 ** the new pager object. If an error occurs, *ppPager is set to NULL
34539 Pager **ppPager, /* OUT: Return the Pager structure here */
34547 Pager *pPager = 0; /* Pager object to allocate and return */
34614 /* Allocate memory for the Pager structure, PCache object, the
34618 ** Pager object (sizeof(Pager) bytes)
34627 ROUND8(sizeof(*pPager)) + /* Pager structure */
34639 pPager = (Pager*)(pPtr);
34647 /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
34659 /* Open the pager file.
34714 ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
34723 ** Pager structure and close the file.
34792 ** the file-system for the given pager. A hot journal is one that
34820 static int hasHotJournal(Pager *pPager, int *pExists){
34906 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
34913 Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
34954 ** 1) If the pager
34963 ** 2) If the pager is running in exclusive-mode, and there are currently
34970 ** pager is in an error state other than SQLITE_FULL when this is called,
34978 SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
34988 ** the error. Discard the contents of the pager-cache and rollback
35072 ** may mean that the pager was in the error-state when this
35158 ** transaction and unlock the pager.
35164 static void pagerUnlockIfUnused(Pager *pPager){
35173 ** Acquire a reference to page number pgno in pager pPager (a page
35205 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
35223 Pager *pPager, /* The pager open on the database file */
35238 /* If the pager is in the error state, return an error immediately.
35248 ** pager was already in the error-state when this function was called.
35264 /* The pager cache has created a new page. Its content needs to
35336 ** pager is in PAGER_UNLOCK state when this function is called,
35337 ** or if the pager is in an error state other than SQLITE_FULL.
35345 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
35365 Pager *pPager = pPg->pPager;
35380 static int openSubJournal(Pager *pPager){
35397 pager pPager and write a journal header
35408 ** Pager.pInJournal bitvec structure is allocated.
35411 ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
35414 static int pager_open_journal(Pager *pPager){
35488 ** Begin a write-transaction on the specified pager object. If a
35512 SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
35540 /* This happens when the pager was in exclusive-access mode the last
35557 ** purpose of this call is to reset the internal state of the pager
35570 ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
35575 Pager *pPager = pPg->pPager;
35732 Pager *pPager = pPg->pPager;
35829 ** A call to this routine tells the pager that it is not necessary to
35836 ** on the given page is unused. The pager marks the page as clean so
35843 Pager *pPager = pPg->pPager;
35858 ** byte offset 24 of the pager file.
35871 static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
35938 ** Sync the pager file to disk. This is a no-op for in-memory files
35939 ** or pages with the Pager.noSync flag set.
35941 ** If successful, or called on a pager for which it is a no-op, this
35944 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
35956 ** Sync the database file for the pager pPager. zMaster points to the name
35982 Pager *pPager, /* Pager object */
36061 ** current value of Pager.dbSize, set dbSize back to the value
36149 ** If an error occurs, an IO error code is returned and the pager
36152 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
36160 /* This function should not be called if the pager is not in at least
36167 ** this transaction, the pager is running in exclusive-mode and is
36174 ** header. Since the pager is in exclusive mode, there is no need
36212 ** * If the pager is in PAGER_RESERVED state, then attempt (1). Whether
36219 ** (operation 1) failed. However the pager must enter the error state
36233 SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
36259 /* If an error occurs during a ROLLBACK, we can no longer trust the pager
36272 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
36277 ** Return the number of references to the pager.
36279 SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
36294 SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
36312 ** Return true if this is an in-memory pager.
36314 SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
36328 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
36334 PagerSavepoint *aNew; /* New Pager.aSavepoint array */
36341 /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
36391 ** (the first created). A value of (Pager.nSavepoint-1) means operate
36393 ** (Pager.nSavepoint-1), then this function is a no-op.
36409 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
36458 SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager){
36463 ** Return the VFS structure for the pager.
36465 SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
36471 ** with the pager. This might return NULL if the file has
36474 SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
36481 SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
36486 ** Return true if fsync() calls are disabled for this pager. Return FALSE
36489 SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
36495 ** Set or retrieve the codec for this pager
36498 Pager *pPager,
36511 static void *sqlite3PagerGetCodec(Pager *pPager){
36542 SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
36631 ** loading the page into the pager-cache and setting the PgHdr.needSync
36642 ** sure the Pager.needSync flag is set too.
36684 ** Return a pointer to the Pager.nExtra bytes of "extra" space
36692 ** Get/set the locking-mode for this pager. Parameter eMode must be one
36701 SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
36714 ** Get/set the journal-mode for this pager. Parameter eMode must be one of:
36734 SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *pPager, int eMode){
36762 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
36775 SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
36781 /************** End of pager.c ***********************************************/
37092 DbPage *pDbPage; /* Pager page handle */
37204 Pager *pPager; /* The page cache */
37423 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
37838 ** Enable or disable the shared pager and schema features.
38322 ** page from the pager layer with the 'no-content' flag set. True otherwise.
39290 ** Convert a DbPage obtained from the pager into a MemPage used by
39304 ** Get a page from the pager. Initialize the MemPage.pBt and
39331 ** Retrieve a page from the pager cache. If the requested page is not
39332 ** already in the pager cache return NULL. Initialize the MemPage.pBt and
39359 ** Get a page from the pager and initialize it. This routine is just a
39410 ** During a rollback, when the pager reloads information into the cache
39813 ** value of mxPage. If mxPage is negative, the pager will
40317 /* This call makes sure that the pager has the correct number of
40455 Pager *pPager = pBt->pPager;
40674 Pager *pPager = pBt->pPager;
40797 ** call below will unlock the pager. */
40807 ** pager if this call closed the only read or write transaction. */
41008 /* At the pager level, a statement transaction is a savepoint with
41062 ** 2: Other database connections that share the same pager cache
45002 ** Return the pager associated with a BTree. This routine is used for
45005 SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){
45514 ** The pager filename is invariant as long as the pager is
45527 ** The pager journal filename is invariant as long as the pager is
45737 int isAttached; /* True once backup has been registered with pager */
45738 sqlite3_backup *pNext; /* Next backup associated with source pager */
45753 ** invoked by the pager layer to report various state changes in
45895 Pager * const pDestPager = sqlite3BtreePager(p->pDest);
45933 ** and the pager code use this trick (clearing the first byte
45965 ** Register this backup object with the associated source pager for
45991 Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
45992 Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
45997 /* If the source pager is currently in a write-transaction, return
46024 ** source pager for the number of pages in the database.
46180 /* Detach this backup from the source pager. */
46245 ** has been modified by a transaction on the source pager. Copy
46258 ** Restart the backup process. This is called when the pager layer
52978 Pager *pPager;
55251 ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
55282 ** P2==2 is the database format. P2==3 is the recommended pager cache
58140 Pager *pPager;
65828 Pager *pPager;
77339 ** buffer that the pager module resizes using sqlite3_realloc().
77401 Pager *pPager;
77459 Pager *pPager;
77501 Pager *pPager = sqlite3BtreePager(pDb->pBt);
77708 Pager *pPager = sqlite3BtreePager(pDb->pBt);
77722 Pager *pPager = sqlite3BtreePager(pDb->pBt);
78303 Pager *pPager;
85616 ** An optimisation would be to use a non-journaled pager.
85795 ** vacuum database. The vacuum_db journal file is deleted when the pager
96036 ** at the b-tree/pager level.
96642 ** a temporary file for transient pager files and statement journals.
96717 /* If the B-Tree was successfully opened, set the pager-cache size to the
96719 ** open on an existing shared pager-cache, do not change the pager-cache
97124 ** database it is 'NONE'. This matches the pager layer defaults.
97616 Pager *pPager;
