| Index: third_party/sqlite/src/src/pager.c
|
| diff --git a/third_party/sqlite/src/src/pager.c b/third_party/sqlite/src/src/pager.c
|
| index 8561b404c5ce0b24f171277cfd3021fe135f92e7..d932513b892729d539b7ef6381d96b7a1a738f0b 100644
|
| --- a/third_party/sqlite/src/src/pager.c
|
| +++ b/third_party/sqlite/src/src/pager.c
|
| @@ -17,11 +17,97 @@
|
| ** locking to prevent two processes from writing the same database
|
| ** file simultaneously, or one process from reading the database while
|
| ** another is writing.
|
| -**
|
| -** @(#) $Id: pager.c,v 1.629 2009/08/10 17:48:57 drh Exp $
|
| */
|
| #ifndef SQLITE_OMIT_DISKIO
|
| #include "sqliteInt.h"
|
| +#include "wal.h"
|
| +
|
| +
|
| +/******************* NOTES ON THE DESIGN OF THE PAGER ************************
|
| +**
|
| +** This comment block describes invariants that hold when using a rollback
|
| +** journal. These invariants do not apply for journal_mode=WAL,
|
| +** journal_mode=MEMORY, or journal_mode=OFF.
|
| +**
|
| +** Within this comment block, a page is deemed to have been synced
|
| +** automatically as soon as it is written when PRAGMA synchronous=OFF.
|
| +** Otherwise, the page is not synced until the xSync method of the VFS
|
| +** is called successfully on the file containing the page.
|
| +**
|
| +** Definition: A page of the database file is said to be "overwriteable" if
|
| +** one or more of the following are true about the page:
|
| +**
|
| +** (a) The original content of the page as it was at the beginning of
|
| +** the transaction has been written into the rollback journal and
|
| +** synced.
|
| +**
|
| +** (b) The page was a freelist leaf page at the start of the transaction.
|
| +**
|
| +** (c) The page number is greater than the largest page that existed in
|
| +** the database file at the start of the transaction.
|
| +**
|
| +** (1) A page of the database file is never overwritten unless one of the
|
| +** following are true:
|
| +**
|
| +** (a) The page and all other pages on the same sector are overwriteable.
|
| +**
|
| +** (b) The atomic page write optimization is enabled, and the entire
|
| +** transaction other than the update of the transaction sequence
|
| +** number consists of a single page change.
|
| +**
|
| +** (2) The content of a page written into the rollback journal exactly matches
|
| +** both the content in the database when the rollback journal was written
|
| +** and the content in the database at the beginning of the current
|
| +** transaction.
|
| +**
|
| +** (3) Writes to the database file are an integer multiple of the page size
|
| +** in length and are aligned on a page boundary.
|
| +**
|
| +** (4) Reads from the database file are either aligned on a page boundary and
|
| +** an integer multiple of the page size in length or are taken from the
|
| +** first 100 bytes of the database file.
|
| +**
|
| +** (5) All writes to the database file are synced prior to the rollback journal
|
| +** being deleted, truncated, or zeroed.
|
| +**
|
| +** (6) If a master journal file is used, then all writes to the database file
|
| +** are synced prior to the master journal being deleted.
|
| +**
|
| +** Definition: Two databases (or the same database at two points it time)
|
| +** are said to be "logically equivalent" if they give the same answer to
|
| +** all queries. Note in particular the the content of freelist leaf
|
| +** pages can be changed arbitarily without effecting the logical equivalence
|
| +** of the database.
|
| +**
|
| +** (7) At any time, if any subset, including the empty set and the total set,
|
| +** of the unsynced changes to a rollback journal are removed and the
|
| +** journal is rolled back, the resulting database file will be logical
|
| +** equivalent to the database file at the beginning of the transaction.
|
| +**
|
| +** (8) When a transaction is rolled back, the xTruncate method of the VFS
|
| +** is called to restore the database file to the same size it was at
|
| +** the beginning of the transaction. (In some VFSes, the xTruncate
|
| +** method is a no-op, but that does not change the fact the SQLite will
|
| +** invoke it.)
|
| +**
|
| +** (9) Whenever the database file is modified, at least one bit in the range
|
| +** of bytes from 24 through 39 inclusive will be changed prior to releasing
|
| +** the EXCLUSIVE lock, thus signaling other connections on the same
|
| +** database to flush their caches.
|
| +**
|
| +** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
|
| +** than one billion transactions.
|
| +**
|
| +** (11) A database file is well-formed at the beginning and at the conclusion
|
| +** of every transaction.
|
| +**
|
| +** (12) An EXCLUSIVE lock is held on the database file when writing to
|
| +** the database file.
|
| +**
|
| +** (13) A SHARED lock is held on the database file while reading any
|
| +** content out of the database file.
|
| +**
|
| +******************************************************************************/
|
|
|
| /*
|
| ** Macros for troubleshooting. Normally turned off
|
| @@ -46,58 +132,279 @@ int sqlite3PagerTrace=1; /* True to enable tracing */
|
| #define FILEHANDLEID(fd) ((int)fd)
|
|
|
| /*
|
| -** The page cache as a whole is always in one of the following
|
| -** states:
|
| -**
|
| -** PAGER_UNLOCK The page cache is not currently reading or
|
| -** writing the database file. There is no
|
| -** data held in memory. This is the initial
|
| -** state.
|
| -**
|
| -** PAGER_SHARED The page cache is reading the database.
|
| -** Writing is not permitted. There can be
|
| -** multiple readers accessing the same database
|
| -** file at the same time.
|
| -**
|
| -** PAGER_RESERVED This process has reserved the database for writing
|
| -** but has not yet made any changes. Only one process
|
| -** at a time can reserve the database. The original
|
| -** database file has not been modified so other
|
| -** processes may still be reading the on-disk
|
| -** database file.
|
| -**
|
| -** PAGER_EXCLUSIVE The page cache is writing the database.
|
| -** Access is exclusive. No other processes or
|
| -** threads can be reading or writing while one
|
| -** process is writing.
|
| -**
|
| -** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE
|
| -** after all dirty pages have been written to the
|
| -** database file and the file has been synced to
|
| -** disk. All that remains to do is to remove or
|
| -** truncate the journal file and the transaction
|
| -** will be committed.
|
| -**
|
| -** The page cache comes up in PAGER_UNLOCK. The first time a
|
| -** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED.
|
| -** After all pages have been released using sqlite_page_unref(),
|
| -** the state transitions back to PAGER_UNLOCK. The first time
|
| -** that sqlite3PagerWrite() is called, the state transitions to
|
| -** PAGER_RESERVED. (Note that sqlite3PagerWrite() can only be
|
| -** called on an outstanding page which means that the pager must
|
| -** be in PAGER_SHARED before it transitions to PAGER_RESERVED.)
|
| -** PAGER_RESERVED means that there is an open rollback journal.
|
| -** The transition to PAGER_EXCLUSIVE occurs before any changes
|
| -** are made to the database file, though writes to the rollback
|
| -** journal occurs with just PAGER_RESERVED. After an sqlite3PagerRollback()
|
| -** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED,
|
| -** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode.
|
| -*/
|
| -#define PAGER_UNLOCK 0
|
| -#define PAGER_SHARED 1 /* same as SHARED_LOCK */
|
| -#define PAGER_RESERVED 2 /* same as RESERVED_LOCK */
|
| -#define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */
|
| -#define PAGER_SYNCED 5
|
| +** The Pager.eState variable stores the current 'state' of a pager. A
|
| +** pager may be in any one of the seven states shown in the following
|
| +** state diagram.
|
| +**
|
| +** OPEN <------+------+
|
| +** | | |
|
| +** V | |
|
| +** +---------> READER-------+ |
|
| +** | | |
|
| +** | V |
|
| +** |<-------WRITER_LOCKED------> ERROR
|
| +** | | ^
|
| +** | V |
|
| +** |<------WRITER_CACHEMOD-------->|
|
| +** | | |
|
| +** | V |
|
| +** |<-------WRITER_DBMOD---------->|
|
| +** | | |
|
| +** | V |
|
| +** +<------WRITER_FINISHED-------->+
|
| +**
|
| +**
|
| +** List of state transitions and the C [function] that performs each:
|
| +**
|
| +** OPEN -> READER [sqlite3PagerSharedLock]
|
| +** READER -> OPEN [pager_unlock]
|
| +**
|
| +** READER -> WRITER_LOCKED [sqlite3PagerBegin]
|
| +** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
|
| +** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
|
| +** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
|
| +** WRITER_*** -> READER [pager_end_transaction]
|
| +**
|
| +** WRITER_*** -> ERROR [pager_error]
|
| +** ERROR -> OPEN [pager_unlock]
|
| +**
|
| +**
|
| +** OPEN:
|
| +**
|
| +** The pager starts up in this state. Nothing is guaranteed in this
|
| +** state - the file may or may not be locked and the database size is
|
| +** unknown. The database may not be read or written.
|
| +**
|
| +** * No read or write transaction is active.
|
| +** * Any lock, or no lock at all, may be held on the database file.
|
| +** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
|
| +**
|
| +** READER:
|
| +**
|
| +** In this state all the requirements for reading the database in
|
| +** rollback (non-WAL) mode are met. Unless the pager is (or recently
|
| +** was) in exclusive-locking mode, a user-level read transaction is
|
| +** open. The database size is known in this state.
|
| +**
|
| +** A connection running with locking_mode=normal enters this state when
|
| +** it opens a read-transaction on the database and returns to state
|
| +** OPEN after the read-transaction is completed. However a connection
|
| +** running in locking_mode=exclusive (including temp databases) remains in
|
| +** this state even after the read-transaction is closed. The only way
|
| +** a locking_mode=exclusive connection can transition from READER to OPEN
|
| +** is via the ERROR state (see below).
|
| +**
|
| +** * A read transaction may be active (but a write-transaction cannot).
|
| +** * A SHARED or greater lock is held on the database file.
|
| +** * The dbSize variable may be trusted (even if a user-level read
|
| +** transaction is not active). The dbOrigSize and dbFileSize variables
|
| +** may not be trusted at this point.
|
| +** * If the database is a WAL database, then the WAL connection is open.
|
| +** * Even if a read-transaction is not open, it is guaranteed that
|
| +** there is no hot-journal in the file-system.
|
| +**
|
| +** WRITER_LOCKED:
|
| +**
|
| +** The pager moves to this state from READER when a write-transaction
|
| +** is first opened on the database. In WRITER_LOCKED state, all locks
|
| +** required to start a write-transaction are held, but no actual
|
| +** modifications to the cache or database have taken place.
|
| +**
|
| +** In rollback mode, a RESERVED or (if the transaction was opened with
|
| +** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when
|
| +** moving to this state, but the journal file is not written to or opened
|
| +** to in this state. If the transaction is committed or rolled back while
|
| +** in WRITER_LOCKED state, all that is required is to unlock the database
|
| +** file.
|
| +**
|
| +** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
|
| +** If the connection is running with locking_mode=exclusive, an attempt
|
| +** is made to obtain an EXCLUSIVE lock on the database file.
|
| +**
|
| +** * A write transaction is active.
|
| +** * If the connection is open in rollback-mode, a RESERVED or greater
|
| +** lock is held on the database file.
|
| +** * If the connection is open in WAL-mode, a WAL write transaction
|
| +** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
|
| +** called).
|
| +** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
|
| +** * The contents of the pager cache have not been modified.
|
| +** * The journal file may or may not be open.
|
| +** * Nothing (not even the first header) has been written to the journal.
|
| +**
|
| +** WRITER_CACHEMOD:
|
| +**
|
| +** A pager moves from WRITER_LOCKED state to this state when a page is
|
| +** first modified by the upper layer. In rollback mode the journal file
|
| +** is opened (if it is not already open) and a header written to the
|
| +** start of it. The database file on disk has not been modified.
|
| +**
|
| +** * A write transaction is active.
|
| +** * A RESERVED or greater lock is held on the database file.
|
| +** * The journal file is open and the first header has been written
|
| +** to it, but the header has not been synced to disk.
|
| +** * The contents of the page cache have been modified.
|
| +**
|
| +** WRITER_DBMOD:
|
| +**
|
| +** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
|
| +** when it modifies the contents of the database file. WAL connections
|
| +** never enter this state (since they do not modify the database file,
|
| +** just the log file).
|
| +**
|
| +** * A write transaction is active.
|
| +** * An EXCLUSIVE or greater lock is held on the database file.
|
| +** * The journal file is open and the first header has been written
|
| +** and synced to disk.
|
| +** * The contents of the page cache have been modified (and possibly
|
| +** written to disk).
|
| +**
|
| +** WRITER_FINISHED:
|
| +**
|
| +** It is not possible for a WAL connection to enter this state.
|
| +**
|
| +** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
|
| +** state after the entire transaction has been successfully written into the
|
| +** database file. In this state the transaction may be committed simply
|
| +** by finalizing the journal file. Once in WRITER_FINISHED state, it is
|
| +** not possible to modify the database further. At this point, the upper
|
| +** layer must either commit or rollback the transaction.
|
| +**
|
| +** * A write transaction is active.
|
| +** * An EXCLUSIVE or greater lock is held on the database file.
|
| +** * All writing and syncing of journal and database data has finished.
|
| +** If no error occured, all that remains is to finalize the journal to
|
| +** commit the transaction. If an error did occur, the caller will need
|
| +** to rollback the transaction.
|
| +**
|
| +** ERROR:
|
| +**
|
| +** The ERROR state is entered when an IO or disk-full error (including
|
| +** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
|
| +** difficult to be sure that the in-memory pager state (cache contents,
|
| +** db size etc.) are consistent with the contents of the file-system.
|
| +**
|
| +** Temporary pager files may enter the ERROR state, but in-memory pagers
|
| +** cannot.
|
| +**
|
| +** For example, if an IO error occurs while performing a rollback,
|
| +** the contents of the page-cache may be left in an inconsistent state.
|
| +** At this point it would be dangerous to change back to READER state
|
| +** (as usually happens after a rollback). Any subsequent readers might
|
| +** report database corruption (due to the inconsistent cache), and if
|
| +** they upgrade to writers, they may inadvertently corrupt the database
|
| +** file. To avoid this hazard, the pager switches into the ERROR state
|
| +** instead of READER following such an error.
|
| +**
|
| +** Once it has entered the ERROR state, any attempt to use the pager
|
| +** to read or write data returns an error. Eventually, once all
|
| +** outstanding transactions have been abandoned, the pager is able to
|
| +** transition back to OPEN state, discarding the contents of the
|
| +** page-cache and any other in-memory state at the same time. Everything
|
| +** is reloaded from disk (and, if necessary, hot-journal rollback peformed)
|
| +** when a read-transaction is next opened on the pager (transitioning
|
| +** the pager into READER state). At that point the system has recovered
|
| +** from the error.
|
| +**
|
| +** Specifically, the pager jumps into the ERROR state if:
|
| +**
|
| +** 1. An error occurs while attempting a rollback. This happens in
|
| +** function sqlite3PagerRollback().
|
| +**
|
| +** 2. An error occurs while attempting to finalize a journal file
|
| +** following a commit in function sqlite3PagerCommitPhaseTwo().
|
| +**
|
| +** 3. An error occurs while attempting to write to the journal or
|
| +** database file in function pagerStress() in order to free up
|
| +** memory.
|
| +**
|
| +** In other cases, the error is returned to the b-tree layer. The b-tree
|
| +** layer then attempts a rollback operation. If the error condition
|
| +** persists, the pager enters the ERROR state via condition (1) above.
|
| +**
|
| +** Condition (3) is necessary because it can be triggered by a read-only
|
| +** statement executed within a transaction. In this case, if the error
|
| +** code were simply returned to the user, the b-tree layer would not
|
| +** automatically attempt a rollback, as it assumes that an error in a
|
| +** read-only statement cannot leave the pager in an internally inconsistent
|
| +** state.
|
| +**
|
| +** * The Pager.errCode variable is set to something other than SQLITE_OK.
|
| +** * There are one or more outstanding references to pages (after the
|
| +** last reference is dropped the pager should move back to OPEN state).
|
| +** * The pager is not an in-memory pager.
|
| +**
|
| +**
|
| +** Notes:
|
| +**
|
| +** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
|
| +** connection is open in WAL mode. A WAL connection is always in one
|
| +** of the first four states.
|
| +**
|
| +** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
|
| +** state. There are two exceptions: immediately after exclusive-mode has
|
| +** been turned on (and before any read or write transactions are
|
| +** executed), and when the pager is leaving the "error state".
|
| +**
|
| +** * See also: assert_pager_state().
|
| +*/
|
| +#define PAGER_OPEN 0
|
| +#define PAGER_READER 1
|
| +#define PAGER_WRITER_LOCKED 2
|
| +#define PAGER_WRITER_CACHEMOD 3
|
| +#define PAGER_WRITER_DBMOD 4
|
| +#define PAGER_WRITER_FINISHED 5
|
| +#define PAGER_ERROR 6
|
| +
|
| +/*
|
| +** The Pager.eLock variable is almost always set to one of the
|
| +** following locking-states, according to the lock currently held on
|
| +** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
|
| +** This variable is kept up to date as locks are taken and released by
|
| +** the pagerLockDb() and pagerUnlockDb() wrappers.
|
| +**
|
| +** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY
|
| +** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
|
| +** the operation was successful. In these circumstances pagerLockDb() and
|
| +** pagerUnlockDb() take a conservative approach - eLock is always updated
|
| +** when unlocking the file, and only updated when locking the file if the
|
| +** VFS call is successful. This way, the Pager.eLock variable may be set
|
| +** to a less exclusive (lower) value than the lock that is actually held
|
| +** at the system level, but it is never set to a more exclusive value.
|
| +**
|
| +** This is usually safe. If an xUnlock fails or appears to fail, there may
|
| +** be a few redundant xLock() calls or a lock may be held for longer than
|
| +** required, but nothing really goes wrong.
|
| +**
|
| +** The exception is when the database file is unlocked as the pager moves
|
| +** from ERROR to OPEN state. At this point there may be a hot-journal file
|
| +** in the file-system that needs to be rolled back (as part of a OPEN->SHARED
|
| +** transition, by the same pager or any other). If the call to xUnlock()
|
| +** fails at this point and the pager is left holding an EXCLUSIVE lock, this
|
| +** can confuse the call to xCheckReservedLock() call made later as part
|
| +** of hot-journal detection.
|
| +**
|
| +** xCheckReservedLock() is defined as returning true "if there is a RESERVED
|
| +** lock held by this process or any others". So xCheckReservedLock may
|
| +** return true because the caller itself is holding an EXCLUSIVE lock (but
|
| +** doesn't know it because of a previous error in xUnlock). If this happens
|
| +** a hot-journal may be mistaken for a journal being created by an active
|
| +** transaction in another process, causing SQLite to read from the database
|
| +** without rolling it back.
|
| +**
|
| +** To work around this, if a call to xUnlock() fails when unlocking the
|
| +** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
|
| +** is only changed back to a real locking state after a successful call
|
| +** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
|
| +** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
|
| +** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
|
| +** lock on the database file before attempting to roll it back. See function
|
| +** PagerSharedLock() for more detail.
|
| +**
|
| +** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
|
| +** PAGER_OPEN state.
|
| +*/
|
| +#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
|
|
|
| /*
|
| ** A macro used for invoking the codec if there is one
|
| @@ -141,36 +448,34 @@ struct PagerSavepoint {
|
| Bitvec *pInSavepoint; /* Set of pages in this savepoint */
|
| Pgno nOrig; /* Original number of pages in file */
|
| Pgno iSubRec; /* Index of first record in sub-journal */
|
| +#ifndef SQLITE_OMIT_WAL
|
| + u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
|
| +#endif
|
| };
|
|
|
| /*
|
| -** A open page cache is an instance of the following structure.
|
| +** A open page cache is an instance of struct Pager. A description of
|
| +** some of the more important member variables follows:
|
| **
|
| -** errCode
|
| +** eState
|
| +**
|
| +** The current 'state' of the pager object. See the comment and state
|
| +** diagram above for a description of the pager state.
|
| **
|
| -** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or
|
| -** or SQLITE_FULL. Once one of the first three errors occurs, it persists
|
| -** and is returned as the result of every major pager API call. The
|
| -** SQLITE_FULL return code is slightly different. It persists only until the
|
| -** next successful rollback is performed on the pager cache. Also,
|
| -** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup()
|
| -** APIs, they may still be used successfully.
|
| -**
|
| -** dbSizeValid, dbSize, dbOrigSize, dbFileSize
|
| -**
|
| -** Managing the size of the database file in pages is a little complicated.
|
| -** The variable Pager.dbSize contains the number of pages that the database
|
| -** image currently contains. As the database image grows or shrinks this
|
| -** variable is updated. The variable Pager.dbFileSize contains the number
|
| -** of pages in the database file. This may be different from Pager.dbSize
|
| -** if some pages have been appended to the database image but not yet written
|
| -** out from the cache to the actual file on disk. Or if the image has been
|
| -** truncated by an incremental-vacuum operation. The Pager.dbOrigSize variable
|
| -** contains the number of pages in the database image when the current
|
| -** transaction was opened. The contents of all three of these variables is
|
| -** only guaranteed to be correct if the boolean Pager.dbSizeValid is true.
|
| -**
|
| -** TODO: Under what conditions is dbSizeValid set? Cleared?
|
| +** eLock
|
| +**
|
| +** For a real on-disk database, the current lock held on the database file -
|
| +** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
|
| +**
|
| +** For a temporary or in-memory database (neither of which require any
|
| +** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
|
| +** databases always have Pager.exclusiveMode==1, this tricks the pager
|
| +** logic into thinking that it already has all the locks it will ever
|
| +** need (and no reason to release them).
|
| +**
|
| +** In some (obscure) circumstances, this variable may also be set to
|
| +** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
|
| +** details.
|
| **
|
| ** changeCountDone
|
| **
|
| @@ -189,92 +494,153 @@ struct PagerSavepoint {
|
| ** need only update the change-counter once, for the first transaction
|
| ** committed.
|
| **
|
| -** dbModified
|
| -**
|
| -** The dbModified flag is set whenever a database page is dirtied.
|
| -** It is cleared at the end of each transaction.
|
| -**
|
| -** It is used when committing or otherwise ending a transaction. If
|
| -** the dbModified flag is clear then less work has to be done.
|
| -**
|
| -** journalStarted
|
| -**
|
| -** This flag is set whenever the the main journal is synced.
|
| -**
|
| -** The point of this flag is that it must be set after the
|
| -** first journal header in a journal file has been synced to disk.
|
| -** After this has happened, new pages appended to the database
|
| -** do not need the PGHDR_NEED_SYNC flag set, as they do not need
|
| -** to wait for a journal sync before they can be written out to
|
| -** the database file (see function pager_write()).
|
| -**
|
| ** setMaster
|
| **
|
| -** This variable is used to ensure that the master journal file name
|
| -** (if any) is only written into the journal file once.
|
| -**
|
| -** When committing a transaction, the master journal file name (if any)
|
| -** may be written into the journal file while the pager is still in
|
| -** PAGER_RESERVED state (see CommitPhaseOne() for the action). It
|
| -** then attempts to upgrade to an exclusive lock. If this attempt
|
| -** fails, then SQLITE_BUSY may be returned to the user and the user
|
| -** may attempt to commit the transaction again later (calling
|
| -** CommitPhaseOne() again). This flag is used to ensure that the
|
| -** master journal name is only written to the journal file the first
|
| -** time CommitPhaseOne() is called.
|
| -**
|
| -** doNotSync
|
| -**
|
| -** This variable is set and cleared by sqlite3PagerWrite().
|
| -**
|
| -** needSync
|
| -**
|
| -** TODO: It might be easier to set this variable in writeJournalHdr()
|
| -** and writeMasterJournal() only. Change its meaning to "unsynced data
|
| -** has been written to the journal".
|
| +** When PagerCommitPhaseOne() is called to commit a transaction, it may
|
| +** (or may not) specify a master-journal name to be written into the
|
| +** journal file before it is synced to disk.
|
| +**
|
| +** Whether or not a journal file contains a master-journal pointer affects
|
| +** the way in which the journal file is finalized after the transaction is
|
| +** committed or rolled back when running in "journal_mode=PERSIST" mode.
|
| +** If a journal file does not contain a master-journal pointer, it is
|
| +** finalized by overwriting the first journal header with zeroes. If
|
| +** it does contain a master-journal pointer the journal file is finalized
|
| +** by truncating it to zero bytes, just as if the connection were
|
| +** running in "journal_mode=truncate" mode.
|
| +**
|
| +** Journal files that contain master journal pointers cannot be finalized
|
| +** simply by overwriting the first journal-header with zeroes, as the
|
| +** master journal pointer could interfere with hot-journal rollback of any
|
| +** subsequently interrupted transaction that reuses the journal file.
|
| +**
|
| +** The flag is cleared as soon as the journal file is finalized (either
|
| +** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
|
| +** journal file from being successfully finalized, the setMaster flag
|
| +** is cleared anyway (and the pager will move to ERROR state).
|
| +**
|
| +** doNotSpill, doNotSyncSpill
|
| +**
|
| +** These two boolean variables control the behaviour of cache-spills
|
| +** (calls made by the pcache module to the pagerStress() routine to
|
| +** write cached data to the file-system in order to free up memory).
|
| +**
|
| +** When doNotSpill is non-zero, writing to the database from pagerStress()
|
| +** is disabled altogether. This is done in a very obscure case that
|
| +** comes up during savepoint rollback that requires the pcache module
|
| +** to allocate a new page to prevent the journal file from being written
|
| +** while it is being traversed by code in pager_playback().
|
| +**
|
| +** If doNotSyncSpill is non-zero, writing to the database from pagerStress()
|
| +** is permitted, but syncing the journal file is not. This flag is set
|
| +** by sqlite3PagerWrite() when the file-system sector-size is larger than
|
| +** the database page-size in order to prevent a journal sync from happening
|
| +** in between the journalling of two pages on the same sector.
|
| **
|
| ** subjInMemory
|
| **
|
| ** This is a boolean variable. If true, then any required sub-journal
|
| ** is opened as an in-memory journal file. If false, then in-memory
|
| ** sub-journals are only used for in-memory pager files.
|
| +**
|
| +** This variable is updated by the upper layer each time a new
|
| +** write-transaction is opened.
|
| +**
|
| +** dbSize, dbOrigSize, dbFileSize
|
| +**
|
| +** Variable dbSize is set to the number of pages in the database file.
|
| +** It is valid in PAGER_READER and higher states (all states except for
|
| +** OPEN and ERROR).
|
| +**
|
| +** dbSize is set based on the size of the database file, which may be
|
| +** larger than the size of the database (the value stored at offset
|
| +** 28 of the database header by the btree). If the size of the file
|
| +** is not an integer multiple of the page-size, the value stored in
|
| +** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
|
| +** Except, any file that is greater than 0 bytes in size is considered
|
| +** to have at least one page. (i.e. a 1KB file with 2K page-size leads
|
| +** to dbSize==1).
|
| +**
|
| +** During a write-transaction, if pages with page-numbers greater than
|
| +** dbSize are modified in the cache, dbSize is updated accordingly.
|
| +** Similarly, if the database is truncated using PagerTruncateImage(),
|
| +** dbSize is updated.
|
| +**
|
| +** Variables dbOrigSize and dbFileSize are valid in states
|
| +** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
|
| +** variable at the start of the transaction. It is used during rollback,
|
| +** and to determine whether or not pages need to be journalled before
|
| +** being modified.
|
| +**
|
| +** Throughout a write-transaction, dbFileSize contains the size of
|
| +** the file on disk in pages. It is set to a copy of dbSize when the
|
| +** write-transaction is first opened, and updated when VFS calls are made
|
| +** to write or truncate the database file on disk.
|
| +**
|
| +** The only reason the dbFileSize variable is required is to suppress
|
| +** unnecessary calls to xTruncate() after committing a transaction. If,
|
| +** when a transaction is committed, the dbFileSize variable indicates
|
| +** that the database file is larger than the database image (Pager.dbSize),
|
| +** pager_truncate() is called. The pager_truncate() call uses xFilesize()
|
| +** to measure the database file on disk, and then truncates it if required.
|
| +** dbFileSize is not used when rolling back a transaction. In this case
|
| +** pager_truncate() is called unconditionally (which means there may be
|
| +** a call to xFilesize() that is not strictly required). In either case,
|
| +** pager_truncate() may cause the file to become smaller or larger.
|
| +**
|
| +** dbHintSize
|
| +**
|
| +** The dbHintSize variable is used to limit the number of calls made to
|
| +** the VFS xFileControl(FCNTL_SIZE_HINT) method.
|
| +**
|
| +** dbHintSize is set to a copy of the dbSize variable when a
|
| +** write-transaction is opened (at the same time as dbFileSize and
|
| +** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
|
| +** dbHintSize is increased to the number of pages that correspond to the
|
| +** size-hint passed to the method call. See pager_write_pagelist() for
|
| +** details.
|
| +**
|
| +** errCode
|
| +**
|
| +** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
|
| +** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
|
| +** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
|
| +** sub-codes.
|
| */
|
| struct Pager {
|
| sqlite3_vfs *pVfs; /* OS functions to use for IO */
|
| u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
|
| - u8 journalMode; /* On of the PAGER_JOURNALMODE_* values */
|
| + u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
|
| u8 useJournal; /* Use a rollback journal on this file */
|
| u8 noReadlock; /* Do not bother to obtain readlocks */
|
| u8 noSync; /* Do not sync the journal if true */
|
| u8 fullSync; /* Do extra syncs of the journal for robustness */
|
| - u8 sync_flags; /* One of SYNC_NORMAL or SYNC_FULL */
|
| + u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */
|
| + u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
|
| u8 tempFile; /* zFilename is a temporary file */
|
| u8 readOnly; /* True for a read-only database */
|
| u8 memDb; /* True to inhibit all file I/O */
|
|
|
| - /* The following block contains those class members that are dynamically
|
| - ** modified during normal operations. The other variables in this structure
|
| - ** are either constant throughout the lifetime of the pager, or else
|
| - ** used to store configuration parameters that affect the way the pager
|
| - ** operates.
|
| - **
|
| - ** The 'state' variable is described in more detail along with the
|
| - ** descriptions of the values it may take - PAGER_UNLOCK etc. Many of the
|
| - ** other variables in this block are described in the comment directly
|
| - ** above this class definition.
|
| + /**************************************************************************
|
| + ** The following block contains those class members that change during
|
| + ** routine opertion. Class members not in this block are either fixed
|
| + ** when the pager is first created or else only change when there is a
|
| + ** significant mode change (such as changing the page_size, locking_mode,
|
| + ** or the journal_mode). From another view, these class members describe
|
| + ** the "state" of the pager, while other class members describe the
|
| + ** "configuration" of the pager.
|
| */
|
| - u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */
|
| - u8 dbModified; /* True if there are any changes to the Db */
|
| - u8 needSync; /* True if an fsync() is needed on the journal */
|
| - u8 journalStarted; /* True if header of journal is synced */
|
| + u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
|
| + u8 eLock; /* Current lock held on database file */
|
| u8 changeCountDone; /* Set after incrementing the change-counter */
|
| u8 setMaster; /* True if a m-j name has been written to jrnl */
|
| - u8 doNotSync; /* Boolean. While true, do not spill the cache */
|
| - u8 dbSizeValid; /* Set when dbSize is correct */
|
| + u8 doNotSpill; /* Do not spill the cache when non-zero */
|
| + u8 doNotSyncSpill; /* Do not do a spill that requires jrnl sync */
|
| u8 subjInMemory; /* True to use in-memory sub-journals */
|
| Pgno dbSize; /* Number of pages in the database */
|
| Pgno dbOrigSize; /* dbSize before the current transaction */
|
| Pgno dbFileSize; /* Number of pages in the database file */
|
| + Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
|
| int errCode; /* One of several kinds of errors */
|
| int nRec; /* Pages journalled since last j-header written */
|
| u32 cksumInit; /* Quasi-random value added to every checksum */
|
| @@ -285,16 +651,21 @@ struct Pager {
|
| sqlite3_file *sjfd; /* File descriptor for sub-journal */
|
| i64 journalOff; /* Current write offset in the journal file */
|
| i64 journalHdr; /* Byte offset to previous journal header */
|
| + sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
|
| PagerSavepoint *aSavepoint; /* Array of active savepoints */
|
| int nSavepoint; /* Number of elements in aSavepoint[] */
|
| char dbFileVers[16]; /* Changes whenever database file changes */
|
| - u32 sectorSize; /* Assumed sector size during rollback */
|
| + /*
|
| + ** End of the routinely-changing class members
|
| + ***************************************************************************/
|
|
|
| u16 nExtra; /* Add this many bytes to each in-memory page */
|
| i16 nReserve; /* Number of unused bytes at end of each page */
|
| u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
|
| + u32 sectorSize; /* Assumed sector size during rollback */
|
| int pageSize; /* Number of bytes in a page */
|
| Pgno mxPgno; /* Maximum allowed size of the database */
|
| + i64 journalSizeLimit; /* Size limit for persistent journal files */
|
| char *zFilename; /* Name of the database file */
|
| char *zJournal; /* Name of the journal file */
|
| int (*xBusyHandler)(void*); /* Function to call when busy */
|
| @@ -311,9 +682,11 @@ struct Pager {
|
| void *pCodec; /* First argument to xCodec... methods */
|
| #endif
|
| char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
|
| - i64 journalSizeLimit; /* Size limit for persistent journal files */
|
| PCache *pPCache; /* Pointer to page cache object */
|
| - sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
|
| +#ifndef SQLITE_OMIT_WAL
|
| + Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
|
| + char *zWal; /* File name for write-ahead log */
|
| +#endif
|
| };
|
|
|
| /*
|
| @@ -388,6 +761,36 @@ static const unsigned char aJournalMagic[] = {
|
| */
|
| #define PAGER_MAX_PGNO 2147483647
|
|
|
| +/*
|
| +** The argument to this macro is a file descriptor (type sqlite3_file*).
|
| +** Return 0 if it is not open, or non-zero (but not 1) if it is.
|
| +**
|
| +** This is so that expressions can be written as:
|
| +**
|
| +** if( isOpen(pPager->jfd) ){ ...
|
| +**
|
| +** instead of
|
| +**
|
| +** if( pPager->jfd->pMethods ){ ...
|
| +*/
|
| +#define isOpen(pFd) ((pFd)->pMethods)
|
| +
|
| +/*
|
| +** Return true if this pager uses a write-ahead log instead of the usual
|
| +** rollback journal. Otherwise false.
|
| +*/
|
| +#ifndef SQLITE_OMIT_WAL
|
| +static int pagerUseWal(Pager *pPager){
|
| + return (pPager->pWal!=0);
|
| +}
|
| +#else
|
| +# define pagerUseWal(x) 0
|
| +# define pagerRollbackWal(x) 0
|
| +# define pagerWalFrames(v,w,x,y,z) 0
|
| +# define pagerOpenWalIfPresent(z) SQLITE_OK
|
| +# define pagerBeginReadTransaction(z) SQLITE_OK
|
| +#endif
|
| +
|
| /* Begin preload-cache.patch for Chromium */
|
| /* See comments above the definition. */
|
| int sqlite3PagerAcquire2(
|
| @@ -403,17 +806,188 @@ int sqlite3PagerAcquire2(
|
| ** Usage:
|
| **
|
| ** assert( assert_pager_state(pPager) );
|
| +**
|
| +** This function runs many asserts to try to find inconsistencies in
|
| +** the internal state of the Pager object.
|
| */
|
| -static int assert_pager_state(Pager *pPager){
|
| +static int assert_pager_state(Pager *p){
|
| + Pager *pPager = p;
|
| +
|
| + /* State must be valid. */
|
| + assert( p->eState==PAGER_OPEN
|
| + || p->eState==PAGER_READER
|
| + || p->eState==PAGER_WRITER_LOCKED
|
| + || p->eState==PAGER_WRITER_CACHEMOD
|
| + || p->eState==PAGER_WRITER_DBMOD
|
| + || p->eState==PAGER_WRITER_FINISHED
|
| + || p->eState==PAGER_ERROR
|
| + );
|
| +
|
| + /* Regardless of the current state, a temp-file connection always behaves
|
| + ** as if it has an exclusive lock on the database file. It never updates
|
| + ** the change-counter field, so the changeCountDone flag is always set.
|
| + */
|
| + assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
|
| + assert( p->tempFile==0 || pPager->changeCountDone );
|
| +
|
| + /* If the useJournal flag is clear, the journal-mode must be "OFF".
|
| + ** And if the journal-mode is "OFF", the journal file must not be open.
|
| + */
|
| + assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
|
| + assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
|
| +
|
| + /* Check that MEMDB implies noSync. And an in-memory journal. Since
|
| + ** this means an in-memory pager performs no IO at all, it cannot encounter
|
| + ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
|
| + ** a journal file. (although the in-memory journal implementation may
|
| + ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
|
| + ** is therefore not possible for an in-memory pager to enter the ERROR
|
| + ** state.
|
| + */
|
| + if( MEMDB ){
|
| + assert( p->noSync );
|
| + assert( p->journalMode==PAGER_JOURNALMODE_OFF
|
| + || p->journalMode==PAGER_JOURNALMODE_MEMORY
|
| + );
|
| + assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
|
| + assert( pagerUseWal(p)==0 );
|
| + }
|
| +
|
| + /* If changeCountDone is set, a RESERVED lock or greater must be held
|
| + ** on the file.
|
| + */
|
| + assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
|
| + assert( p->eLock!=PENDING_LOCK );
|
| +
|
| + switch( p->eState ){
|
| + case PAGER_OPEN:
|
| + assert( !MEMDB );
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
|
| + break;
|
| +
|
| + case PAGER_READER:
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + assert( p->eLock!=UNKNOWN_LOCK );
|
| + assert( p->eLock>=SHARED_LOCK || p->noReadlock );
|
| + break;
|
| +
|
| + case PAGER_WRITER_LOCKED:
|
| + assert( p->eLock!=UNKNOWN_LOCK );
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + if( !pagerUseWal(pPager) ){
|
| + assert( p->eLock>=RESERVED_LOCK );
|
| + }
|
| + assert( pPager->dbSize==pPager->dbOrigSize );
|
| + assert( pPager->dbOrigSize==pPager->dbFileSize );
|
| + assert( pPager->dbOrigSize==pPager->dbHintSize );
|
| + assert( pPager->setMaster==0 );
|
| + break;
|
| +
|
| + case PAGER_WRITER_CACHEMOD:
|
| + assert( p->eLock!=UNKNOWN_LOCK );
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + if( !pagerUseWal(pPager) ){
|
| + /* It is possible that if journal_mode=wal here that neither the
|
| + ** journal file nor the WAL file are open. This happens during
|
| + ** a rollback transaction that switches from journal_mode=off
|
| + ** to journal_mode=wal.
|
| + */
|
| + assert( p->eLock>=RESERVED_LOCK );
|
| + assert( isOpen(p->jfd)
|
| + || p->journalMode==PAGER_JOURNALMODE_OFF
|
| + || p->journalMode==PAGER_JOURNALMODE_WAL
|
| + );
|
| + }
|
| + assert( pPager->dbOrigSize==pPager->dbFileSize );
|
| + assert( pPager->dbOrigSize==pPager->dbHintSize );
|
| + break;
|
| +
|
| + case PAGER_WRITER_DBMOD:
|
| + assert( p->eLock==EXCLUSIVE_LOCK );
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + assert( !pagerUseWal(pPager) );
|
| + assert( p->eLock>=EXCLUSIVE_LOCK );
|
| + assert( isOpen(p->jfd)
|
| + || p->journalMode==PAGER_JOURNALMODE_OFF
|
| + || p->journalMode==PAGER_JOURNALMODE_WAL
|
| + );
|
| + assert( pPager->dbOrigSize<=pPager->dbHintSize );
|
| + break;
|
|
|
| - /* A temp-file is always in PAGER_EXCLUSIVE or PAGER_SYNCED state. */
|
| - assert( pPager->tempFile==0 || pPager->state>=PAGER_EXCLUSIVE );
|
| + case PAGER_WRITER_FINISHED:
|
| + assert( p->eLock==EXCLUSIVE_LOCK );
|
| + assert( pPager->errCode==SQLITE_OK );
|
| + assert( !pagerUseWal(pPager) );
|
| + assert( isOpen(p->jfd)
|
| + || p->journalMode==PAGER_JOURNALMODE_OFF
|
| + || p->journalMode==PAGER_JOURNALMODE_WAL
|
| + );
|
| + break;
|
|
|
| - /* The changeCountDone flag is always set for temp-files */
|
| - assert( pPager->tempFile==0 || pPager->changeCountDone );
|
| + case PAGER_ERROR:
|
| + /* There must be at least one outstanding reference to the pager if
|
| + ** in ERROR state. Otherwise the pager should have already dropped
|
| + ** back to OPEN state.
|
| + */
|
| + assert( pPager->errCode!=SQLITE_OK );
|
| + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
|
| + break;
|
| + }
|
|
|
| return 1;
|
| }
|
| +#endif /* ifndef NDEBUG */
|
| +
|
| +#ifdef SQLITE_DEBUG
|
| +/*
|
| +** Return a pointer to a human readable string in a static buffer
|
| +** containing the state of the Pager object passed as an argument. This
|
| +** is intended to be used within debuggers. For example, as an alternative
|
| +** to "print *pPager" in gdb:
|
| +**
|
| +** (gdb) printf "%s", print_pager_state(pPager)
|
| +*/
|
| +static char *print_pager_state(Pager *p){
|
| + static char zRet[1024];
|
| +
|
| + sqlite3_snprintf(1024, zRet,
|
| + "Filename: %s\n"
|
| + "State: %s errCode=%d\n"
|
| + "Lock: %s\n"
|
| + "Locking mode: locking_mode=%s\n"
|
| + "Journal mode: journal_mode=%s\n"
|
| + "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
|
| + "Journal: journalOff=%lld journalHdr=%lld\n"
|
| + "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
|
| + , p->zFilename
|
| + , p->eState==PAGER_OPEN ? "OPEN" :
|
| + p->eState==PAGER_READER ? "READER" :
|
| + p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
|
| + p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
|
| + p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
|
| + p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
|
| + p->eState==PAGER_ERROR ? "ERROR" : "?error?"
|
| + , (int)p->errCode
|
| + , p->eLock==NO_LOCK ? "NO_LOCK" :
|
| + p->eLock==RESERVED_LOCK ? "RESERVED" :
|
| + p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
|
| + p->eLock==SHARED_LOCK ? "SHARED" :
|
| + p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
|
| + , p->exclusiveMode ? "exclusive" : "normal"
|
| + , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
|
| + p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
|
| + p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
|
| + p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
|
| + p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
|
| + p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
|
| + , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
|
| + , p->journalOff, p->journalHdr
|
| + , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
|
| + );
|
| +
|
| + return zRet;
|
| +}
|
| #endif
|
|
|
| /*
|
| @@ -466,6 +1040,7 @@ static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
|
| */
|
| #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
|
|
|
| +
|
| /*
|
| ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
|
| ** on success or an error code is something goes wrong.
|
| @@ -477,27 +1052,53 @@ static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
|
| }
|
|
|
| /*
|
| -** The argument to this macro is a file descriptor (type sqlite3_file*).
|
| -** Return 0 if it is not open, or non-zero (but not 1) if it is.
|
| -**
|
| -** This is so that expressions can be written as:
|
| -**
|
| -** if( isOpen(pPager->jfd) ){ ...
|
| +** Unlock the database file to level eLock, which must be either NO_LOCK
|
| +** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
|
| +** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
|
| **
|
| -** instead of
|
| -**
|
| -** if( pPager->jfd->pMethods ){ ...
|
| +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
|
| +** called, do not modify it. See the comment above the #define of
|
| +** UNKNOWN_LOCK for an explanation of this.
|
| */
|
| -#define isOpen(pFd) ((pFd)->pMethods)
|
| +static int pagerUnlockDb(Pager *pPager, int eLock){
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( !pPager->exclusiveMode || pPager->eLock==eLock );
|
| + assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
|
| + assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
|
| + if( isOpen(pPager->fd) ){
|
| + assert( pPager->eLock>=eLock );
|
| + rc = sqlite3OsUnlock(pPager->fd, eLock);
|
| + if( pPager->eLock!=UNKNOWN_LOCK ){
|
| + pPager->eLock = (u8)eLock;
|
| + }
|
| + IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
|
| + }
|
| + return rc;
|
| +}
|
|
|
| /*
|
| -** If file pFd is open, call sqlite3OsUnlock() on it.
|
| +** Lock the database file to level eLock, which must be either SHARED_LOCK,
|
| +** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
|
| +** Pager.eLock variable to the new locking state.
|
| +**
|
| +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
|
| +** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
|
| +** See the comment above the #define of UNKNOWN_LOCK for an explanation
|
| +** of this.
|
| */
|
| -static int osUnlock(sqlite3_file *pFd, int eLock){
|
| - if( !isOpen(pFd) ){
|
| - return SQLITE_OK;
|
| +static int pagerLockDb(Pager *pPager, int eLock){
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
|
| + if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
|
| + rc = sqlite3OsLock(pPager->fd, eLock);
|
| + if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
|
| + pPager->eLock = (u8)eLock;
|
| + IOTRACE(("LOCK %p %d\n", pPager, eLock))
|
| + }
|
| }
|
| - return sqlite3OsUnlock(pFd, eLock);
|
| + return rc;
|
| }
|
|
|
| /*
|
| @@ -573,13 +1174,14 @@ static void pager_set_pagehash(PgHdr *pPage){
|
| #define CHECK_PAGE(x) checkPage(x)
|
| static void checkPage(PgHdr *pPg){
|
| Pager *pPager = pPg->pPager;
|
| - assert( !pPg->pageHash || pPager->errCode
|
| - || (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| + assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
|
| }
|
|
|
| #else
|
| #define pager_datahash(X,Y) 0
|
| #define pager_pagehash(X) 0
|
| +#define pager_set_pagehash(X)
|
| #define CHECK_PAGE(x)
|
| #endif /* SQLITE_CHECK_PAGES */
|
|
|
| @@ -708,7 +1310,7 @@ static int zeroJournalHdr(Pager *pPager, int doTruncate){
|
| rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
|
| }
|
| if( rc==SQLITE_OK && !pPager->noSync ){
|
| - rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->sync_flags);
|
| + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
|
| }
|
|
|
| /* At this point the transaction is committed but the write lock
|
| @@ -746,7 +1348,7 @@ static int zeroJournalHdr(Pager *pPager, int doTruncate){
|
| static int writeJournalHdr(Pager *pPager){
|
| int rc = SQLITE_OK; /* Return code */
|
| char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
|
| - u32 nHeader = pPager->pageSize; /* Size of buffer pointed to by zHeader */
|
| + u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
|
| u32 nWrite; /* Bytes of header sector written */
|
| int ii; /* Loop counter */
|
|
|
| @@ -789,7 +1391,7 @@ static int writeJournalHdr(Pager *pPager){
|
| ** that garbage data is never appended to the journal file.
|
| */
|
| assert( isOpen(pPager->fd) || pPager->noSync );
|
| - if( (pPager->noSync) || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
|
| + if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
|
| || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
|
| ){
|
| memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
|
| @@ -837,6 +1439,7 @@ static int writeJournalHdr(Pager *pPager){
|
| for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
|
| IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
|
| rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
|
| + assert( pPager->journalHdr <= pPager->journalOff );
|
| pPager->journalOff += nHeader;
|
| }
|
|
|
| @@ -912,7 +1515,6 @@ static int readJournalHdr(
|
| if( pPager->journalOff==0 ){
|
| u32 iPageSize; /* Page-size field of journal header */
|
| u32 iSectorSize; /* Sector-size field of journal header */
|
| - u16 iPageSize16; /* Copy of iPageSize in 16-bit variable */
|
|
|
| /* Read the page-size and sector-size journal header fields. */
|
| if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
|
| @@ -921,12 +1523,20 @@ static int readJournalHdr(
|
| return rc;
|
| }
|
|
|
| + /* Versions of SQLite prior to 3.5.8 set the page-size field of the
|
| + ** journal header to zero. In this case, assume that the Pager.pageSize
|
| + ** variable is already set to the correct page size.
|
| + */
|
| + if( iPageSize==0 ){
|
| + iPageSize = pPager->pageSize;
|
| + }
|
| +
|
| /* Check that the values read from the page-size and sector-size fields
|
| ** are within range. To be 'in range', both values need to be a power
|
| - ** of two greater than or equal to 512, and not greater than their
|
| + ** of two greater than or equal to 512 or 32, and not greater than their
|
| ** respective compile time maximum limits.
|
| */
|
| - if( iPageSize<512 || iSectorSize<512
|
| + if( iPageSize<512 || iSectorSize<32
|
| || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
|
| || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
|
| ){
|
| @@ -942,10 +1552,8 @@ static int readJournalHdr(
|
| ** Use a testcase() macro to make sure that malloc failure within
|
| ** PagerSetPagesize() is tested.
|
| */
|
| - iPageSize16 = (u16)iPageSize;
|
| - rc = sqlite3PagerSetPagesize(pPager, &iPageSize16, -1);
|
| + rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
|
| testcase( rc!=SQLITE_OK );
|
| - assert( rc!=SQLITE_OK || iPageSize16==(u16)iPageSize );
|
|
|
| /* Update the assumed sector-size to match the value used by
|
| ** the process that created this journal. If this journal was
|
| @@ -987,7 +1595,10 @@ static int writeMasterJournal(Pager *pPager, const char *zMaster){
|
| i64 jrnlSize; /* Size of journal file on disk */
|
| u32 cksum = 0; /* Checksum of string zMaster */
|
|
|
| - if( !zMaster || pPager->setMaster
|
| + assert( pPager->setMaster==0 );
|
| + assert( !pagerUseWal(pPager) );
|
| +
|
| + if( !zMaster
|
| || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
|
| || pPager->journalMode==PAGER_JOURNALMODE_OFF
|
| ){
|
| @@ -995,6 +1606,7 @@ static int writeMasterJournal(Pager *pPager, const char *zMaster){
|
| }
|
| pPager->setMaster = 1;
|
| assert( isOpen(pPager->jfd) );
|
| + assert( pPager->journalHdr <= pPager->journalOff );
|
|
|
| /* Calculate the length in bytes and the checksum of zMaster */
|
| for(nMaster=0; zMaster[nMaster]; nMaster++){
|
| @@ -1022,7 +1634,6 @@ static int writeMasterJournal(Pager *pPager, const char *zMaster){
|
| return rc;
|
| }
|
| pPager->journalOff += (nMaster+20);
|
| - pPager->needSync = !pPager->noSync;
|
|
|
| /* If the pager is in peristent-journal mode, then the physical
|
| ** journal-file may extend past the end of the master-journal name
|
| @@ -1058,17 +1669,11 @@ static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
|
| }
|
|
|
| /*
|
| -** Unless the pager is in error-state, discard all in-memory pages. If
|
| -** the pager is in error-state, then this call is a no-op.
|
| -**
|
| -** TODO: Why can we not reset the pager while in error state?
|
| +** Discard the entire contents of the in-memory page-cache.
|
| */
|
| static void pager_reset(Pager *pPager){
|
| - if( SQLITE_OK==pPager->errCode ){
|
| - sqlite3BackupRestart(pPager->pBackup);
|
| - sqlite3PcacheClear(pPager->pPCache);
|
| - pPager->dbSizeValid = 0;
|
| - }
|
| + sqlite3BackupRestart(pPager->pBackup);
|
| + sqlite3PcacheClear(pPager->pPCache);
|
| }
|
|
|
| /*
|
| @@ -1111,70 +1716,108 @@ static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
|
| }
|
|
|
| /*
|
| -** Unlock the database file. This function is a no-op if the pager
|
| -** is in exclusive mode.
|
| -**
|
| -** If the pager is currently in error state, discard the contents of
|
| -** the cache and reset the Pager structure internal state. If there is
|
| -** an open journal-file, then the next time a shared-lock is obtained
|
| -** on the pager file (by this or any other process), it will be
|
| -** treated as a hot-journal and rolled back.
|
| +** This function is a no-op if the pager is in exclusive mode and not
|
| +** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
|
| +** state.
|
| +**
|
| +** If the pager is not in exclusive-access mode, the database file is
|
| +** completely unlocked. If the file is unlocked and the file-system does
|
| +** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
|
| +** closed (if it is open).
|
| +**
|
| +** If the pager is in ERROR state when this function is called, the
|
| +** contents of the pager cache are discarded before switching back to
|
| +** the OPEN state. Regardless of whether the pager is in exclusive-mode
|
| +** or not, any journal file left in the file-system will be treated
|
| +** as a hot-journal and rolled back the next time a read-transaction
|
| +** is opened (by this or by any other connection).
|
| */
|
| static void pager_unlock(Pager *pPager){
|
| - if( !pPager->exclusiveMode ){
|
| - int rc; /* Return code */
|
|
|
| - /* Always close the journal file when dropping the database lock.
|
| - ** Otherwise, another connection with journal_mode=delete might
|
| - ** delete the file out from under us.
|
| - */
|
| - sqlite3OsClose(pPager->jfd);
|
| - sqlite3BitvecDestroy(pPager->pInJournal);
|
| - pPager->pInJournal = 0;
|
| - releaseAllSavepoints(pPager);
|
| + assert( pPager->eState==PAGER_READER
|
| + || pPager->eState==PAGER_OPEN
|
| + || pPager->eState==PAGER_ERROR
|
| + );
|
|
|
| - /* If the file is unlocked, somebody else might change it. The
|
| - ** values stored in Pager.dbSize etc. might become invalid if
|
| - ** this happens. TODO: Really, this doesn't need to be cleared
|
| - ** until the change-counter check fails in PagerSharedLock().
|
| - */
|
| - pPager->dbSizeValid = 0;
|
| + sqlite3BitvecDestroy(pPager->pInJournal);
|
| + pPager->pInJournal = 0;
|
| + releaseAllSavepoints(pPager);
|
|
|
| - rc = osUnlock(pPager->fd, NO_LOCK);
|
| - if( rc ){
|
| - pPager->errCode = rc;
|
| + if( pagerUseWal(pPager) ){
|
| + assert( !isOpen(pPager->jfd) );
|
| + sqlite3WalEndReadTransaction(pPager->pWal);
|
| + pPager->eState = PAGER_OPEN;
|
| + }else if( !pPager->exclusiveMode ){
|
| + int rc; /* Error code returned by pagerUnlockDb() */
|
| + int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
|
| +
|
| + /* If the operating system support deletion of open files, then
|
| + ** close the journal file when dropping the database lock. Otherwise
|
| + ** another connection with journal_mode=delete might delete the file
|
| + ** out from under us.
|
| + */
|
| + assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
|
| + assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
|
| + assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
|
| + assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
|
| + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
|
| + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
|
| + if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
|
| + || 1!=(pPager->journalMode & 5)
|
| + ){
|
| + sqlite3OsClose(pPager->jfd);
|
| }
|
| - IOTRACE(("UNLOCK %p\n", pPager))
|
|
|
| - /* If Pager.errCode is set, the contents of the pager cache cannot be
|
| - ** trusted. Now that the pager file is unlocked, the contents of the
|
| - ** cache can be discarded and the error code safely cleared.
|
| + /* If the pager is in the ERROR state and the call to unlock the database
|
| + ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
|
| + ** above the #define for UNKNOWN_LOCK for an explanation of why this
|
| + ** is necessary.
|
| */
|
| - if( pPager->errCode ){
|
| - if( rc==SQLITE_OK ){
|
| - pPager->errCode = SQLITE_OK;
|
| - }
|
| - pager_reset(pPager);
|
| + rc = pagerUnlockDb(pPager, NO_LOCK);
|
| + if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
|
| + pPager->eLock = UNKNOWN_LOCK;
|
| }
|
|
|
| + /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
|
| + ** without clearing the error code. This is intentional - the error
|
| + ** code is cleared and the cache reset in the block below.
|
| + */
|
| + assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
|
| pPager->changeCountDone = 0;
|
| - pPager->state = PAGER_UNLOCK;
|
| + pPager->eState = PAGER_OPEN;
|
| + }
|
| +
|
| + /* If Pager.errCode is set, the contents of the pager cache cannot be
|
| + ** trusted. Now that there are no outstanding references to the pager,
|
| + ** it can safely move back to PAGER_OPEN state. This happens in both
|
| + ** normal and exclusive-locking mode.
|
| + */
|
| + if( pPager->errCode ){
|
| + assert( !MEMDB );
|
| + pager_reset(pPager);
|
| + pPager->changeCountDone = pPager->tempFile;
|
| + pPager->eState = PAGER_OPEN;
|
| + pPager->errCode = SQLITE_OK;
|
| }
|
| +
|
| + pPager->journalOff = 0;
|
| + pPager->journalHdr = 0;
|
| + pPager->setMaster = 0;
|
| }
|
|
|
| /*
|
| -** This function should be called when an IOERR, CORRUPT or FULL error
|
| -** may have occurred. The first argument is a pointer to the pager
|
| -** structure, the second the error-code about to be returned by a pager
|
| -** API function. The value returned is a copy of the second argument
|
| -** to this function.
|
| -**
|
| -** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL
|
| -** the error becomes persistent. Until the persisten error is cleared,
|
| -** subsequent API calls on this Pager will immediately return the same
|
| -** error code.
|
| -**
|
| -** A persistent error indicates that the contents of the pager-cache
|
| +** This function is called whenever an IOERR or FULL error that requires
|
| +** the pager to transition into the ERROR state may ahve occurred.
|
| +** The first argument is a pointer to the pager structure, the second
|
| +** the error-code about to be returned by a pager API function. The
|
| +** value returned is a copy of the second argument to this function.
|
| +**
|
| +** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
|
| +** IOERR sub-codes, the pager enters the ERROR state and the error code
|
| +** is stored in Pager.errCode. While the pager remains in the ERROR state,
|
| +** all major API calls on the Pager will immediately return Pager.errCode.
|
| +**
|
| +** The ERROR state indicates that the contents of the pager-cache
|
| ** cannot be trusted. This state can be cleared by completely discarding
|
| ** the contents of the pager-cache. If a transaction was active when
|
| ** the persistent error occurred, then the rollback journal may need
|
| @@ -1191,45 +1834,21 @@ static int pager_error(Pager *pPager, int rc){
|
| );
|
| if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
|
| pPager->errCode = rc;
|
| + pPager->eState = PAGER_ERROR;
|
| }
|
| return rc;
|
| }
|
|
|
| /*
|
| -** Execute a rollback if a transaction is active and unlock the
|
| -** database file.
|
| -**
|
| -** If the pager has already entered the error state, do not attempt
|
| -** the rollback at this time. Instead, pager_unlock() is called. The
|
| -** call to pager_unlock() will discard all in-memory pages, unlock
|
| -** the database file and clear the error state. If this means that
|
| -** there is a hot-journal left in the file-system, the next connection
|
| -** to obtain a shared lock on the pager (which may be this one) will
|
| -** roll it back.
|
| -**
|
| -** If the pager has not already entered the error state, but an IO or
|
| -** malloc error occurs during a rollback, then this will itself cause
|
| -** the pager to enter the error state. Which will be cleared by the
|
| -** call to pager_unlock(), as described above.
|
| -*/
|
| -static void pagerUnlockAndRollback(Pager *pPager){
|
| - if( pPager->errCode==SQLITE_OK && pPager->state>=PAGER_RESERVED ){
|
| - sqlite3BeginBenignMalloc();
|
| - sqlite3PagerRollback(pPager);
|
| - sqlite3EndBenignMalloc();
|
| - }
|
| - pager_unlock(pPager);
|
| -}
|
| -
|
| -/*
|
| ** This routine ends a transaction. A transaction is usually ended by
|
| ** either a COMMIT or a ROLLBACK operation. This routine may be called
|
| ** after rollback of a hot-journal, or if an error occurs while opening
|
| ** the journal file or writing the very first journal-header of a
|
| ** database transaction.
|
| **
|
| -** If the pager is in PAGER_SHARED or PAGER_UNLOCK state when this
|
| -** routine is called, it is a no-op (returns SQLITE_OK).
|
| +** This routine is never called in PAGER_ERROR state. If it is called
|
| +** in PAGER_NONE or PAGER_SHARED state and the lock held is less
|
| +** exclusive than a RESERVED lock, it is a no-op.
|
| **
|
| ** Otherwise, any active savepoints are released.
|
| **
|
| @@ -1260,13 +1879,9 @@ static void pagerUnlockAndRollback(Pager *pPager){
|
| ** DELETE and the pager is in exclusive mode, the method described under
|
| ** journalMode==PERSIST is used instead.
|
| **
|
| -** After the journal is finalized, if running in non-exclusive mode, the
|
| -** pager moves to PAGER_SHARED state (and downgrades the lock on the
|
| -** database file accordingly).
|
| -**
|
| -** If the pager is running in exclusive mode and is in PAGER_SYNCED state,
|
| -** it moves to PAGER_EXCLUSIVE. No locks are downgraded when running in
|
| -** exclusive mode.
|
| +** After the journal is finalized, the pager moves to PAGER_READER state.
|
| +** If running in non-exclusive rollback mode, the lock on the file is
|
| +** downgraded to a SHARED_LOCK.
|
| **
|
| ** SQLITE_OK is returned if no error occurs. If an error occurs during
|
| ** any of the IO operations to finalize the journal file or unlock the
|
| @@ -1281,13 +1896,29 @@ static int pager_end_transaction(Pager *pPager, int hasMaster){
|
| int rc = SQLITE_OK; /* Error code from journal finalization operation */
|
| int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
|
|
|
| - if( pPager->state<PAGER_RESERVED ){
|
| + /* Do nothing if the pager does not have an open write transaction
|
| + ** or at least a RESERVED lock. This function may be called when there
|
| + ** is no write-transaction active but a RESERVED or greater lock is
|
| + ** held under two circumstances:
|
| + **
|
| + ** 1. After a successful hot-journal rollback, it is called with
|
| + ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
|
| + **
|
| + ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
|
| + ** lock switches back to locking_mode=normal and then executes a
|
| + ** read-transaction, this function is called with eState==PAGER_READER
|
| + ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
|
| + */
|
| + assert( assert_pager_state(pPager) );
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| + if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
|
| return SQLITE_OK;
|
| }
|
| - releaseAllSavepoints(pPager);
|
|
|
| + releaseAllSavepoints(pPager);
|
| assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
|
| if( isOpen(pPager->jfd) ){
|
| + assert( !pagerUseWal(pPager) );
|
|
|
| /* Finalize the journal file. */
|
| if( sqlite3IsMemJournal(pPager->jfd) ){
|
| @@ -1300,61 +1931,98 @@ static int pager_end_transaction(Pager *pPager, int hasMaster){
|
| rc = sqlite3OsTruncate(pPager->jfd, 0);
|
| }
|
| pPager->journalOff = 0;
|
| - pPager->journalStarted = 0;
|
| - }else if( pPager->exclusiveMode
|
| - || pPager->journalMode==PAGER_JOURNALMODE_PERSIST
|
| + }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
|
| + || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
|
| ){
|
| rc = zeroJournalHdr(pPager, hasMaster);
|
| - pager_error(pPager, rc);
|
| pPager->journalOff = 0;
|
| - pPager->journalStarted = 0;
|
| }else{
|
| /* This branch may be executed with Pager.journalMode==MEMORY if
|
| ** a hot-journal was just rolled back. In this case the journal
|
| ** file should be closed and deleted. If this connection writes to
|
| - ** the database file, it will do so using an in-memory journal. */
|
| + ** the database file, it will do so using an in-memory journal.
|
| + */
|
| assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
|
| || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
|
| + || pPager->journalMode==PAGER_JOURNALMODE_WAL
|
| );
|
| sqlite3OsClose(pPager->jfd);
|
| if( !pPager->tempFile ){
|
| rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
|
| }
|
| }
|
| + }
|
|
|
| #ifdef SQLITE_CHECK_PAGES
|
| - sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
|
| + sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
|
| + if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
|
| + PgHdr *p = pager_lookup(pPager, 1);
|
| + if( p ){
|
| + p->pageHash = 0;
|
| + sqlite3PagerUnref(p);
|
| + }
|
| + }
|
| #endif
|
|
|
| - sqlite3PcacheCleanAll(pPager->pPCache);
|
| - sqlite3BitvecDestroy(pPager->pInJournal);
|
| - pPager->pInJournal = 0;
|
| - pPager->nRec = 0;
|
| - }
|
| + sqlite3BitvecDestroy(pPager->pInJournal);
|
| + pPager->pInJournal = 0;
|
| + pPager->nRec = 0;
|
| + sqlite3PcacheCleanAll(pPager->pPCache);
|
| + sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
|
|
|
| - if( !pPager->exclusiveMode ){
|
| - rc2 = osUnlock(pPager->fd, SHARED_LOCK);
|
| - pPager->state = PAGER_SHARED;
|
| + if( pagerUseWal(pPager) ){
|
| + /* Drop the WAL write-lock, if any. Also, if the connection was in
|
| + ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
|
| + ** lock held on the database file.
|
| + */
|
| + rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
|
| + assert( rc2==SQLITE_OK );
|
| + }
|
| + if( !pPager->exclusiveMode
|
| + && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
|
| + ){
|
| + rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
|
| pPager->changeCountDone = 0;
|
| - }else if( pPager->state==PAGER_SYNCED ){
|
| - pPager->state = PAGER_EXCLUSIVE;
|
| }
|
| + pPager->eState = PAGER_READER;
|
| pPager->setMaster = 0;
|
| - pPager->needSync = 0;
|
| - pPager->dbModified = 0;
|
| -
|
| - /* TODO: Is this optimal? Why is the db size invalidated here
|
| - ** when the database file is not unlocked? */
|
| - pPager->dbOrigSize = 0;
|
| - sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
|
| - if( !MEMDB ){
|
| - pPager->dbSizeValid = 0;
|
| - }
|
|
|
| return (rc==SQLITE_OK?rc2:rc);
|
| }
|
|
|
| /*
|
| +** Execute a rollback if a transaction is active and unlock the
|
| +** database file.
|
| +**
|
| +** If the pager has already entered the ERROR state, do not attempt
|
| +** the rollback at this time. Instead, pager_unlock() is called. The
|
| +** call to pager_unlock() will discard all in-memory pages, unlock
|
| +** the database file and move the pager back to OPEN state. If this
|
| +** means that there is a hot-journal left in the file-system, the next
|
| +** connection to obtain a shared lock on the pager (which may be this one)
|
| +** will roll it back.
|
| +**
|
| +** If the pager has not already entered the ERROR state, but an IO or
|
| +** malloc error occurs during a rollback, then this will itself cause
|
| +** the pager to enter the ERROR state. Which will be cleared by the
|
| +** call to pager_unlock(), as described above.
|
| +*/
|
| +static void pagerUnlockAndRollback(Pager *pPager){
|
| + if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
|
| + assert( assert_pager_state(pPager) );
|
| + if( pPager->eState>=PAGER_WRITER_LOCKED ){
|
| + sqlite3BeginBenignMalloc();
|
| + sqlite3PagerRollback(pPager);
|
| + sqlite3EndBenignMalloc();
|
| + }else if( !pPager->exclusiveMode ){
|
| + assert( pPager->eState==PAGER_READER );
|
| + pager_end_transaction(pPager, 0);
|
| + }
|
| + }
|
| + pager_unlock(pPager);
|
| +}
|
| +
|
| +/*
|
| ** Parameter aData must point to a buffer of pPager->pageSize bytes
|
| ** of data. Compute and return a checksum based ont the contents of the
|
| ** page of data and the current value of pPager->cksumInit.
|
| @@ -1384,14 +2052,28 @@ static u32 pager_cksum(Pager *pPager, const u8 *aData){
|
| }
|
|
|
| /*
|
| +** Report the current page size and number of reserved bytes back
|
| +** to the codec.
|
| +*/
|
| +#ifdef SQLITE_HAS_CODEC
|
| +static void pagerReportSize(Pager *pPager){
|
| + if( pPager->xCodecSizeChng ){
|
| + pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
|
| + (int)pPager->nReserve);
|
| + }
|
| +}
|
| +#else
|
| +# define pagerReportSize(X) /* No-op if we do not support a codec */
|
| +#endif
|
| +
|
| +/*
|
| ** Read a single page from either the journal file (if isMainJrnl==1) or
|
| ** from the sub-journal (if isMainJrnl==0) and playback that page.
|
| ** The page begins at offset *pOffset into the file. The *pOffset
|
| ** value is increased to the start of the next page in the journal.
|
| **
|
| -** The isMainJrnl flag is true if this is the main rollback journal and
|
| -** false for the statement journal. The main rollback journal uses
|
| -** checksums - the statement journal does not.
|
| +** The main rollback journal uses checksums - the statement journal does
|
| +** not.
|
| **
|
| ** If the page number of the page record read from the (sub-)journal file
|
| ** is greater than the current value of Pager.dbSize, then playback is
|
| @@ -1423,26 +2105,38 @@ static u32 pager_cksum(Pager *pPager, const u8 *aData){
|
| */
|
| static int pager_playback_one_page(
|
| Pager *pPager, /* The pager being played back */
|
| - int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
|
| - int isUnsync, /* True if reading from unsynced main journal */
|
| i64 *pOffset, /* Offset of record to playback */
|
| - int isSavepnt, /* True for a savepoint rollback */
|
| - Bitvec *pDone /* Bitvec of pages already played back */
|
| + Bitvec *pDone, /* Bitvec of pages already played back */
|
| + int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
|
| + int isSavepnt /* True for a savepoint rollback */
|
| ){
|
| int rc;
|
| PgHdr *pPg; /* An existing page in the cache */
|
| Pgno pgno; /* The page number of a page in journal */
|
| u32 cksum; /* Checksum used for sanity checking */
|
| - u8 *aData; /* Temporary storage for the page */
|
| + char *aData; /* Temporary storage for the page */
|
| sqlite3_file *jfd; /* The file descriptor for the journal file */
|
| + int isSynced; /* True if journal page is synced */
|
|
|
| assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
|
| assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
|
| assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
|
| assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
|
|
|
| - aData = (u8*)pPager->pTmpSpace;
|
| + aData = pPager->pTmpSpace;
|
| assert( aData ); /* Temp storage must have already been allocated */
|
| + assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
|
| +
|
| + /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
|
| + ** or savepoint rollback done at the request of the caller) or this is
|
| + ** a hot-journal rollback. If it is a hot-journal rollback, the pager
|
| + ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
|
| + ** only reads from the main journal, not the sub-journal.
|
| + */
|
| + assert( pPager->eState>=PAGER_WRITER_CACHEMOD
|
| + || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
|
| + );
|
| + assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
|
|
|
| /* Read the page number and page data from the journal or sub-journal
|
| ** file. Return an error code to the caller if an IO error occurs.
|
| @@ -1450,7 +2144,7 @@ static int pager_playback_one_page(
|
| jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
|
| rc = read32bits(jfd, *pOffset, &pgno);
|
| if( rc!=SQLITE_OK ) return rc;
|
| - rc = sqlite3OsRead(jfd, aData, pPager->pageSize, (*pOffset)+4);
|
| + rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
|
| if( rc!=SQLITE_OK ) return rc;
|
| *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
|
|
|
| @@ -1469,18 +2163,26 @@ static int pager_playback_one_page(
|
| if( isMainJrnl ){
|
| rc = read32bits(jfd, (*pOffset)-4, &cksum);
|
| if( rc ) return rc;
|
| - if( !isSavepnt && pager_cksum(pPager, aData)!=cksum ){
|
| + if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
|
| return SQLITE_DONE;
|
| }
|
| }
|
|
|
| + /* If this page has already been played by before during the current
|
| + ** rollback, then don't bother to play it back again.
|
| + */
|
| if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
|
| return rc;
|
| }
|
|
|
| - assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE );
|
| + /* When playing back page 1, restore the nReserve setting
|
| + */
|
| + if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
|
| + pPager->nReserve = ((u8*)aData)[20];
|
| + pagerReportSize(pPager);
|
| + }
|
|
|
| - /* If the pager is in RESERVED state, then there must be a copy of this
|
| + /* If the pager is in CACHEMOD state, then there must be a copy of this
|
| ** page in the pager cache. In this case just update the pager cache,
|
| ** not the database file. The page is left marked dirty in this case.
|
| **
|
| @@ -1491,8 +2193,11 @@ static int pager_playback_one_page(
|
| ** either. So the condition described in the above paragraph is not
|
| ** assert()able.
|
| **
|
| - ** If in EXCLUSIVE state, then we update the pager cache if it exists
|
| - ** and the main file. The page is then marked not dirty.
|
| + ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
|
| + ** pager cache if it exists and the main file. The page is then marked
|
| + ** not dirty. Since this code is only executed in PAGER_OPEN state for
|
| + ** a hot-journal rollback, it is guaranteed that the page-cache is empty
|
| + ** if the pager is in OPEN state.
|
| **
|
| ** Ticket #1171: The statement journal might contain page content that is
|
| ** different from the page content at the start of the transaction.
|
| @@ -1512,26 +2217,37 @@ static int pager_playback_one_page(
|
| ** is possible to fail a statement on a database that does not yet exist.
|
| ** Do not attempt to write if database file has never been opened.
|
| */
|
| - pPg = pager_lookup(pPager, pgno);
|
| + if( pagerUseWal(pPager) ){
|
| + pPg = 0;
|
| + }else{
|
| + pPg = pager_lookup(pPager, pgno);
|
| + }
|
| assert( pPg || !MEMDB );
|
| + assert( pPager->eState!=PAGER_OPEN || pPg==0 );
|
| PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
|
| - PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData),
|
| - (isMainJrnl?"main-journal":"sub-journal")
|
| + PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
|
| + (isMainJrnl?"main-journal":"sub-journal")
|
| ));
|
| - if( (pPager->state>=PAGER_EXCLUSIVE)
|
| - && (pPg==0 || 0==(pPg->flags&PGHDR_NEED_SYNC))
|
| - && isOpen(pPager->fd)
|
| - && !isUnsync
|
| + if( isMainJrnl ){
|
| + isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
|
| + }else{
|
| + isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
|
| + }
|
| + if( isOpen(pPager->fd)
|
| + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
|
| + && isSynced
|
| ){
|
| i64 ofst = (pgno-1)*(i64)pPager->pageSize;
|
| - rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, ofst);
|
| + testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
|
| + assert( !pagerUseWal(pPager) );
|
| + rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
|
| if( pgno>pPager->dbFileSize ){
|
| pPager->dbFileSize = pgno;
|
| }
|
| if( pPager->pBackup ){
|
| CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
|
| - sqlite3BackupUpdate(pPager->pBackup, pgno, aData);
|
| - CODEC1(pPager, aData, pgno, 0, rc=SQLITE_NOMEM);
|
| + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
|
| + CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
|
| }
|
| }else if( !isMainJrnl && pPg==0 ){
|
| /* If this is a rollback of a savepoint and data was not written to
|
| @@ -1551,9 +2267,12 @@ static int pager_playback_one_page(
|
| ** requiring a journal-sync before it is written.
|
| */
|
| assert( isSavepnt );
|
| - if( (rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1))!=SQLITE_OK ){
|
| - return rc;
|
| - }
|
| + assert( pPager->doNotSpill==0 );
|
| + pPager->doNotSpill++;
|
| + rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
|
| + assert( pPager->doNotSpill==1 );
|
| + pPager->doNotSpill--;
|
| + if( rc!=SQLITE_OK ) return rc;
|
| pPg->flags &= ~PGHDR_NEED_READ;
|
| sqlite3PcacheMakeDirty(pPg);
|
| }
|
| @@ -1566,13 +2285,14 @@ static int pager_playback_one_page(
|
| */
|
| void *pData;
|
| pData = pPg->pData;
|
| - memcpy(pData, aData, pPager->pageSize);
|
| + memcpy(pData, (u8*)aData, pPager->pageSize);
|
| pPager->xReiniter(pPg);
|
| if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
|
| /* If the contents of this page were just restored from the main
|
| ** journal file, then its content must be as they were when the
|
| ** transaction was first opened. In this case we can mark the page
|
| - ** as clean, since there will be no need to write it out to the.
|
| + ** as clean, since there will be no need to write it out to the
|
| + ** database.
|
| **
|
| ** There is one exception to this rule. If the page is being rolled
|
| ** back as part of a savepoint (or statement) rollback from an
|
| @@ -1587,11 +2307,11 @@ static int pager_playback_one_page(
|
| ** segment is synced. If a crash occurs during or following this,
|
| ** database corruption may ensue.
|
| */
|
| + assert( !pagerUseWal(pPager) );
|
| sqlite3PcacheMakeClean(pPg);
|
| }
|
| -#ifdef SQLITE_CHECK_PAGES
|
| - pPg->pageHash = pager_pagehash(pPg);
|
| -#endif
|
| + pager_set_pagehash(pPg);
|
| +
|
| /* If this was page 1, then restore the value of Pager.dbFileVers.
|
| ** Do this before any decoding. */
|
| if( pgno==1 ){
|
| @@ -1655,6 +2375,9 @@ static int pager_delmaster(Pager *pPager, const char *zMaster){
|
| sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
|
| char *zMasterJournal = 0; /* Contents of master journal file */
|
| i64 nMasterJournal; /* Size of master journal file */
|
| + char *zJournal; /* Pointer to one journal within MJ file */
|
| + char *zMasterPtr; /* Space to hold MJ filename from a journal file */
|
| + int nMasterPtr; /* Amount of space allocated to zMasterPtr[] */
|
|
|
| /* Allocate space for both the pJournal and pMaster file descriptors.
|
| ** If successful, open the master journal file for reading.
|
| @@ -1669,73 +2392,68 @@ static int pager_delmaster(Pager *pPager, const char *zMaster){
|
| }
|
| if( rc!=SQLITE_OK ) goto delmaster_out;
|
|
|
| + /* Load the entire master journal file into space obtained from
|
| + ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
|
| + ** sufficient space (in zMasterPtr) to hold the names of master
|
| + ** journal files extracted from regular rollback-journals.
|
| + */
|
| rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
|
| if( rc!=SQLITE_OK ) goto delmaster_out;
|
| + nMasterPtr = pVfs->mxPathname+1;
|
| + zMasterJournal = sqlite3Malloc((int)nMasterJournal + nMasterPtr + 1);
|
| + if( !zMasterJournal ){
|
| + rc = SQLITE_NOMEM;
|
| + goto delmaster_out;
|
| + }
|
| + zMasterPtr = &zMasterJournal[nMasterJournal+1];
|
| + rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
|
| + if( rc!=SQLITE_OK ) goto delmaster_out;
|
| + zMasterJournal[nMasterJournal] = 0;
|
|
|
| - if( nMasterJournal>0 ){
|
| - char *zJournal;
|
| - char *zMasterPtr = 0;
|
| - int nMasterPtr = pVfs->mxPathname+1;
|
| -
|
| - /* Load the entire master journal file into space obtained from
|
| - ** sqlite3_malloc() and pointed to by zMasterJournal.
|
| - */
|
| - zMasterJournal = sqlite3Malloc((int)nMasterJournal + nMasterPtr + 1);
|
| - if( !zMasterJournal ){
|
| - rc = SQLITE_NOMEM;
|
| + zJournal = zMasterJournal;
|
| + while( (zJournal-zMasterJournal)<nMasterJournal ){
|
| + int exists;
|
| + rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
|
| + if( rc!=SQLITE_OK ){
|
| goto delmaster_out;
|
| }
|
| - zMasterPtr = &zMasterJournal[nMasterJournal+1];
|
| - rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
|
| - if( rc!=SQLITE_OK ) goto delmaster_out;
|
| - zMasterJournal[nMasterJournal] = 0;
|
| -
|
| - zJournal = zMasterJournal;
|
| - while( (zJournal-zMasterJournal)<nMasterJournal ){
|
| - int exists;
|
| - rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
|
| + if( exists ){
|
| + /* One of the journals pointed to by the master journal exists.
|
| + ** Open it and check if it points at the master journal. If
|
| + ** so, return without deleting the master journal file.
|
| + */
|
| + int c;
|
| + int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
|
| + rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
|
| if( rc!=SQLITE_OK ){
|
| goto delmaster_out;
|
| }
|
| - if( exists ){
|
| - /* One of the journals pointed to by the master journal exists.
|
| - ** Open it and check if it points at the master journal. If
|
| - ** so, return without deleting the master journal file.
|
| - */
|
| - int c;
|
| - int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
|
| - rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
|
| - if( rc!=SQLITE_OK ){
|
| - goto delmaster_out;
|
| - }
|
|
|
| - rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
|
| - sqlite3OsClose(pJournal);
|
| - if( rc!=SQLITE_OK ){
|
| - goto delmaster_out;
|
| - }
|
| + rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
|
| + sqlite3OsClose(pJournal);
|
| + if( rc!=SQLITE_OK ){
|
| + goto delmaster_out;
|
| + }
|
|
|
| - c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
|
| - if( c ){
|
| - /* We have a match. Do not delete the master journal file. */
|
| - goto delmaster_out;
|
| - }
|
| + c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
|
| + if( c ){
|
| + /* We have a match. Do not delete the master journal file. */
|
| + goto delmaster_out;
|
| }
|
| - zJournal += (sqlite3Strlen30(zJournal)+1);
|
| }
|
| + zJournal += (sqlite3Strlen30(zJournal)+1);
|
| }
|
| -
|
| +
|
| + sqlite3OsClose(pMaster);
|
| rc = sqlite3OsDelete(pVfs, zMaster, 0);
|
|
|
| delmaster_out:
|
| - if( zMasterJournal ){
|
| - sqlite3_free(zMasterJournal);
|
| - }
|
| + sqlite3_free(zMasterJournal);
|
| if( pMaster ){
|
| sqlite3OsClose(pMaster);
|
| assert( !isOpen(pJournal) );
|
| + sqlite3_free(pMaster);
|
| }
|
| - sqlite3_free(pMaster);
|
| return rc;
|
| }
|
|
|
| @@ -1745,10 +2463,10 @@ delmaster_out:
|
| ** file in the file-system. This only happens when committing a transaction,
|
| ** or rolling back a transaction (including rolling back a hot-journal).
|
| **
|
| -** If the main database file is not open, or an exclusive lock is not
|
| -** held, this function is a no-op. Otherwise, the size of the file is
|
| -** changed to nPage pages (nPage*pPager->pageSize bytes). If the file
|
| -** on disk is currently larger than nPage pages, then use the VFS
|
| +** If the main database file is not open, or the pager is not in either
|
| +** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
|
| +** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
|
| +** If the file on disk is currently larger than nPage pages, then use the VFS
|
| ** xTruncate() method to truncate it.
|
| **
|
| ** Or, it might might be the case that the file on disk is smaller than
|
| @@ -1762,16 +2480,28 @@ delmaster_out:
|
| */
|
| static int pager_truncate(Pager *pPager, Pgno nPage){
|
| int rc = SQLITE_OK;
|
| - if( pPager->state>=PAGER_EXCLUSIVE && isOpen(pPager->fd) ){
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| + assert( pPager->eState!=PAGER_READER );
|
| +
|
| + if( isOpen(pPager->fd)
|
| + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
|
| + ){
|
| i64 currentSize, newSize;
|
| + int szPage = pPager->pageSize;
|
| + assert( pPager->eLock==EXCLUSIVE_LOCK );
|
| /* TODO: Is it safe to use Pager.dbFileSize here? */
|
| rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
|
| - newSize = pPager->pageSize*(i64)nPage;
|
| + newSize = szPage*(i64)nPage;
|
| if( rc==SQLITE_OK && currentSize!=newSize ){
|
| if( currentSize>newSize ){
|
| rc = sqlite3OsTruncate(pPager->fd, newSize);
|
| }else{
|
| - rc = sqlite3OsWrite(pPager->fd, "", 1, newSize-1);
|
| + char *pTmp = pPager->pTmpSpace;
|
| + memset(pTmp, 0, szPage);
|
| + testcase( (newSize-szPage) < currentSize );
|
| + testcase( (newSize-szPage) == currentSize );
|
| + testcase( (newSize-szPage) > currentSize );
|
| + rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
|
| }
|
| if( rc==SQLITE_OK ){
|
| pPager->dbFileSize = nPage;
|
| @@ -1791,8 +2521,8 @@ static int pager_truncate(Pager *pPager, Pgno nPage){
|
| ** For temporary files the effective sector size is always 512 bytes.
|
| **
|
| ** Otherwise, for non-temporary files, the effective sector size is
|
| -** the value returned by the xSectorSize() method rounded up to 512 if
|
| -** it is less than 512, or rounded down to MAX_SECTOR_SIZE if it
|
| +** the value returned by the xSectorSize() method rounded up to 32 if
|
| +** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
|
| ** is greater than MAX_SECTOR_SIZE.
|
| */
|
| static void setSectorSize(Pager *pPager){
|
| @@ -1805,7 +2535,7 @@ static void setSectorSize(Pager *pPager){
|
| */
|
| pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
|
| }
|
| - if( pPager->sectorSize<512 ){
|
| + if( pPager->sectorSize<32 ){
|
| pPager->sectorSize = 512;
|
| }
|
| if( pPager->sectorSize>MAX_SECTOR_SIZE ){
|
| @@ -1830,21 +2560,15 @@ static void setSectorSize(Pager *pPager){
|
| ** database to during a rollback.
|
| ** (5) 4 byte big-endian integer which is the sector size. The header
|
| ** is this many bytes in size.
|
| -** (6) 4 byte big-endian integer which is the page case.
|
| -** (7) 4 byte integer which is the number of bytes in the master journal
|
| -** name. The value may be zero (indicate that there is no master
|
| -** journal.)
|
| -** (8) N bytes of the master journal name. The name will be nul-terminated
|
| -** and might be shorter than the value read from (5). If the first byte
|
| -** of the name is \000 then there is no master journal. The master
|
| -** journal name is stored in UTF-8.
|
| -** (9) Zero or more pages instances, each as follows:
|
| +** (6) 4 byte big-endian integer which is the page size.
|
| +** (7) zero padding out to the next sector size.
|
| +** (8) Zero or more pages instances, each as follows:
|
| ** + 4 byte page number.
|
| ** + pPager->pageSize bytes of data.
|
| ** + 4 byte checksum
|
| **
|
| -** When we speak of the journal header, we mean the first 8 items above.
|
| -** Each entry in the journal is an instance of the 9th item.
|
| +** When we speak of the journal header, we mean the first 7 items above.
|
| +** Each entry in the journal is an instance of the 8th item.
|
| **
|
| ** Call the value from the second bullet "nRec". nRec is the number of
|
| ** valid page entries in the journal. In most cases, you can compute the
|
| @@ -1893,7 +2617,7 @@ static int pager_playback(Pager *pPager, int isHot){
|
| */
|
| assert( isOpen(pPager->jfd) );
|
| rc = sqlite3OsFileSize(pPager->jfd, &szJ);
|
| - if( rc!=SQLITE_OK || szJ==0 ){
|
| + if( rc!=SQLITE_OK ){
|
| goto end_playback;
|
| }
|
|
|
| @@ -1925,11 +2649,9 @@ static int pager_playback(Pager *pPager, int isHot){
|
| ** occurs.
|
| */
|
| while( 1 ){
|
| - int isUnsync = 0;
|
| -
|
| /* Read the next journal header from the journal file. If there are
|
| ** not enough bytes left in the journal file for a complete header, or
|
| - ** it is corrupted, then a process must of failed while writing it.
|
| + ** it is corrupted, then a process must have failed while writing it.
|
| ** This indicates nothing more needs to be rolled back.
|
| */
|
| rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
|
| @@ -1967,7 +2689,6 @@ static int pager_playback(Pager *pPager, int isHot){
|
| if( nRec==0 && !isHot &&
|
| pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
|
| nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
|
| - isUnsync = 1;
|
| }
|
|
|
| /* If this is the first header read from the journal, truncate the
|
| @@ -1989,12 +2710,20 @@ static int pager_playback(Pager *pPager, int isHot){
|
| pager_reset(pPager);
|
| needPagerReset = 0;
|
| }
|
| - rc = pager_playback_one_page(pPager,1,isUnsync,&pPager->journalOff,0,0);
|
| + rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
|
| if( rc!=SQLITE_OK ){
|
| if( rc==SQLITE_DONE ){
|
| rc = SQLITE_OK;
|
| pPager->journalOff = szJ;
|
| break;
|
| + }else if( rc==SQLITE_IOERR_SHORT_READ ){
|
| + /* If the journal has been truncated, simply stop reading and
|
| + ** processing the journal. This might happen if the journal was
|
| + ** not completely written and synced prior to a crash. In that
|
| + ** case, the database should have never been written in the
|
| + ** first place so it is OK to simply abandon the rollback. */
|
| + rc = SQLITE_OK;
|
| + goto end_playback;
|
| }else{
|
| /* If we are unable to rollback, quit and return the error
|
| ** code. This will cause the pager to enter the error state
|
| @@ -2036,6 +2765,11 @@ end_playback:
|
| rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
|
| testcase( rc!=SQLITE_OK );
|
| }
|
| + if( rc==SQLITE_OK
|
| + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
|
| + ){
|
| + rc = sqlite3PagerSync(pPager);
|
| + }
|
| if( rc==SQLITE_OK ){
|
| rc = pager_end_transaction(pPager, zMaster[0]!='\0');
|
| testcase( rc!=SQLITE_OK );
|
| @@ -2056,6 +2790,369 @@ end_playback:
|
| return rc;
|
| }
|
|
|
| +
|
| +/*
|
| +** Read the content for page pPg out of the database file and into
|
| +** pPg->pData. A shared lock or greater must be held on the database
|
| +** file before this function is called.
|
| +**
|
| +** If page 1 is read, then the value of Pager.dbFileVers[] is set to
|
| +** the value read from the database file.
|
| +**
|
| +** If an IO error occurs, then the IO error is returned to the caller.
|
| +** Otherwise, SQLITE_OK is returned.
|
| +*/
|
| +static int readDbPage(PgHdr *pPg){
|
| + Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
|
| + Pgno pgno = pPg->pgno; /* Page number to read */
|
| + int rc = SQLITE_OK; /* Return code */
|
| + int isInWal = 0; /* True if page is in log file */
|
| + int pgsz = pPager->pageSize; /* Number of bytes to read */
|
| +
|
| + assert( pPager->eState>=PAGER_READER && !MEMDB );
|
| + assert( isOpen(pPager->fd) );
|
| +
|
| + if( NEVER(!isOpen(pPager->fd)) ){
|
| + assert( pPager->tempFile );
|
| + memset(pPg->pData, 0, pPager->pageSize);
|
| + return SQLITE_OK;
|
| + }
|
| +
|
| + if( pagerUseWal(pPager) ){
|
| + /* Try to pull the page from the write-ahead log. */
|
| + rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
|
| + }
|
| + if( rc==SQLITE_OK && !isInWal ){
|
| + i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
|
| + rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
|
| + if( rc==SQLITE_IOERR_SHORT_READ ){
|
| + rc = SQLITE_OK;
|
| + }
|
| + }
|
| +
|
| + if( pgno==1 ){
|
| + if( rc ){
|
| + /* If the read is unsuccessful, set the dbFileVers[] to something
|
| + ** that will never be a valid file version. dbFileVers[] is a copy
|
| + ** of bytes 24..39 of the database. Bytes 28..31 should always be
|
| + ** zero or the size of the database in page. Bytes 32..35 and 35..39
|
| + ** should be page numbers which are never 0xffffffff. So filling
|
| + ** pPager->dbFileVers[] with all 0xff bytes should suffice.
|
| + **
|
| + ** For an encrypted database, the situation is more complex: bytes
|
| + ** 24..39 of the database are white noise. But the probability of
|
| + ** white noising equaling 16 bytes of 0xff is vanishingly small so
|
| + ** we should still be ok.
|
| + */
|
| + memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
|
| + }else{
|
| + u8 *dbFileVers = &((u8*)pPg->pData)[24];
|
| + memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
|
| + }
|
| + }
|
| + CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
|
| +
|
| + PAGER_INCR(sqlite3_pager_readdb_count);
|
| + PAGER_INCR(pPager->nRead);
|
| + IOTRACE(("PGIN %p %d\n", pPager, pgno));
|
| + PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
|
| + PAGERID(pPager), pgno, pager_pagehash(pPg)));
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Update the value of the change-counter at offsets 24 and 92 in
|
| +** the header and the sqlite version number at offset 96.
|
| +**
|
| +** This is an unconditional update. See also the pager_incr_changecounter()
|
| +** routine which only updates the change-counter if the update is actually
|
| +** needed, as determined by the pPager->changeCountDone state variable.
|
| +*/
|
| +static void pager_write_changecounter(PgHdr *pPg){
|
| + u32 change_counter;
|
| +
|
| + /* Increment the value just read and write it back to byte 24. */
|
| + change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
|
| + put32bits(((char*)pPg->pData)+24, change_counter);
|
| +
|
| + /* Also store the SQLite version number in bytes 96..99 and in
|
| + ** bytes 92..95 store the change counter for which the version number
|
| + ** is valid. */
|
| + put32bits(((char*)pPg->pData)+92, change_counter);
|
| + put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
|
| +}
|
| +
|
| +#ifndef SQLITE_OMIT_WAL
|
| +/*
|
| +** This function is invoked once for each page that has already been
|
| +** written into the log file when a WAL transaction is rolled back.
|
| +** Parameter iPg is the page number of said page. The pCtx argument
|
| +** is actually a pointer to the Pager structure.
|
| +**
|
| +** If page iPg is present in the cache, and has no outstanding references,
|
| +** it is discarded. Otherwise, if there are one or more outstanding
|
| +** references, the page content is reloaded from the database. If the
|
| +** attempt to reload content from the database is required and fails,
|
| +** return an SQLite error code. Otherwise, SQLITE_OK.
|
| +*/
|
| +static int pagerUndoCallback(void *pCtx, Pgno iPg){
|
| + int rc = SQLITE_OK;
|
| + Pager *pPager = (Pager *)pCtx;
|
| + PgHdr *pPg;
|
| +
|
| + pPg = sqlite3PagerLookup(pPager, iPg);
|
| + if( pPg ){
|
| + if( sqlite3PcachePageRefcount(pPg)==1 ){
|
| + sqlite3PcacheDrop(pPg);
|
| + }else{
|
| + rc = readDbPage(pPg);
|
| + if( rc==SQLITE_OK ){
|
| + pPager->xReiniter(pPg);
|
| + }
|
| + sqlite3PagerUnref(pPg);
|
| + }
|
| + }
|
| +
|
| + /* Normally, if a transaction is rolled back, any backup processes are
|
| + ** updated as data is copied out of the rollback journal and into the
|
| + ** database. This is not generally possible with a WAL database, as
|
| + ** rollback involves simply truncating the log file. Therefore, if one
|
| + ** or more frames have already been written to the log (and therefore
|
| + ** also copied into the backup databases) as part of this transaction,
|
| + ** the backups must be restarted.
|
| + */
|
| + sqlite3BackupRestart(pPager->pBackup);
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function is called to rollback a transaction on a WAL database.
|
| +*/
|
| +static int pagerRollbackWal(Pager *pPager){
|
| + int rc; /* Return Code */
|
| + PgHdr *pList; /* List of dirty pages to revert */
|
| +
|
| + /* For all pages in the cache that are currently dirty or have already
|
| + ** been written (but not committed) to the log file, do one of the
|
| + ** following:
|
| + **
|
| + ** + Discard the cached page (if refcount==0), or
|
| + ** + Reload page content from the database (if refcount>0).
|
| + */
|
| + pPager->dbSize = pPager->dbOrigSize;
|
| + rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
|
| + pList = sqlite3PcacheDirtyList(pPager->pPCache);
|
| + while( pList && rc==SQLITE_OK ){
|
| + PgHdr *pNext = pList->pDirty;
|
| + rc = pagerUndoCallback((void *)pPager, pList->pgno);
|
| + pList = pNext;
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function is a wrapper around sqlite3WalFrames(). As well as logging
|
| +** the contents of the list of pages headed by pList (connected by pDirty),
|
| +** this function notifies any active backup processes that the pages have
|
| +** changed.
|
| +**
|
| +** The list of pages passed into this routine is always sorted by page number.
|
| +** Hence, if page 1 appears anywhere on the list, it will be the first page.
|
| +*/
|
| +static int pagerWalFrames(
|
| + Pager *pPager, /* Pager object */
|
| + PgHdr *pList, /* List of frames to log */
|
| + Pgno nTruncate, /* Database size after this commit */
|
| + int isCommit, /* True if this is a commit */
|
| + int syncFlags /* Flags to pass to OsSync() (or 0) */
|
| +){
|
| + int rc; /* Return code */
|
| +#if defined(SQLITE_DEBUG) || defined(SQLITE_CHECK_PAGES)
|
| + PgHdr *p; /* For looping over pages */
|
| +#endif
|
| +
|
| + assert( pPager->pWal );
|
| +#ifdef SQLITE_DEBUG
|
| + /* Verify that the page list is in accending order */
|
| + for(p=pList; p && p->pDirty; p=p->pDirty){
|
| + assert( p->pgno < p->pDirty->pgno );
|
| + }
|
| +#endif
|
| +
|
| + if( isCommit ){
|
| + /* If a WAL transaction is being committed, there is no point in writing
|
| + ** any pages with page numbers greater than nTruncate into the WAL file.
|
| + ** They will never be read by any client. So remove them from the pDirty
|
| + ** list here. */
|
| + PgHdr *p;
|
| + PgHdr **ppNext = &pList;
|
| + for(p=pList; (*ppNext = p); p=p->pDirty){
|
| + if( p->pgno<=nTruncate ) ppNext = &p->pDirty;
|
| + }
|
| + assert( pList );
|
| + }
|
| +
|
| + if( pList->pgno==1 ) pager_write_changecounter(pList);
|
| + rc = sqlite3WalFrames(pPager->pWal,
|
| + pPager->pageSize, pList, nTruncate, isCommit, syncFlags
|
| + );
|
| + if( rc==SQLITE_OK && pPager->pBackup ){
|
| + PgHdr *p;
|
| + for(p=pList; p; p=p->pDirty){
|
| + sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
|
| + }
|
| + }
|
| +
|
| +#ifdef SQLITE_CHECK_PAGES
|
| + pList = sqlite3PcacheDirtyList(pPager->pPCache);
|
| + for(p=pList; p; p=p->pDirty){
|
| + pager_set_pagehash(p);
|
| + }
|
| +#endif
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Begin a read transaction on the WAL.
|
| +**
|
| +** This routine used to be called "pagerOpenSnapshot()" because it essentially
|
| +** makes a snapshot of the database at the current point in time and preserves
|
| +** that snapshot for use by the reader in spite of concurrently changes by
|
| +** other writers or checkpointers.
|
| +*/
|
| +static int pagerBeginReadTransaction(Pager *pPager){
|
| + int rc; /* Return code */
|
| + int changed = 0; /* True if cache must be reset */
|
| +
|
| + assert( pagerUseWal(pPager) );
|
| + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
|
| +
|
| + /* sqlite3WalEndReadTransaction() was not called for the previous
|
| + ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
|
| + ** are in locking_mode=NORMAL and EndRead() was previously called,
|
| + ** the duplicate call is harmless.
|
| + */
|
| + sqlite3WalEndReadTransaction(pPager->pWal);
|
| +
|
| + rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
|
| + if( rc!=SQLITE_OK || changed ){
|
| + pager_reset(pPager);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +#endif
|
| +
|
| +/*
|
| +** This function is called as part of the transition from PAGER_OPEN
|
| +** to PAGER_READER state to determine the size of the database file
|
| +** in pages (assuming the page size currently stored in Pager.pageSize).
|
| +**
|
| +** If no error occurs, SQLITE_OK is returned and the size of the database
|
| +** in pages is stored in *pnPage. Otherwise, an error code (perhaps
|
| +** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
|
| +*/
|
| +static int pagerPagecount(Pager *pPager, Pgno *pnPage){
|
| + Pgno nPage; /* Value to return via *pnPage */
|
| +
|
| + /* Query the WAL sub-system for the database size. The WalDbsize()
|
| + ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
|
| + ** if the database size is not available. The database size is not
|
| + ** available from the WAL sub-system if the log file is empty or
|
| + ** contains no valid committed transactions.
|
| + */
|
| + assert( pPager->eState==PAGER_OPEN );
|
| + assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
|
| + nPage = sqlite3WalDbsize(pPager->pWal);
|
| +
|
| + /* If the database size was not available from the WAL sub-system,
|
| + ** determine it based on the size of the database file. If the size
|
| + ** of the database file is not an integer multiple of the page-size,
|
| + ** round down to the nearest page. Except, any file larger than 0
|
| + ** bytes in size is considered to contain at least one page.
|
| + */
|
| + if( nPage==0 ){
|
| + i64 n = 0; /* Size of db file in bytes */
|
| + assert( isOpen(pPager->fd) || pPager->tempFile );
|
| + if( isOpen(pPager->fd) ){
|
| + int rc = sqlite3OsFileSize(pPager->fd, &n);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| + }
|
| + nPage = (Pgno)(n / pPager->pageSize);
|
| + if( nPage==0 && n>0 ){
|
| + nPage = 1;
|
| + }
|
| + }
|
| +
|
| + /* If the current number of pages in the file is greater than the
|
| + ** configured maximum pager number, increase the allowed limit so
|
| + ** that the file can be read.
|
| + */
|
| + if( nPage>pPager->mxPgno ){
|
| + pPager->mxPgno = (Pgno)nPage;
|
| + }
|
| +
|
| + *pnPage = nPage;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +#ifndef SQLITE_OMIT_WAL
|
| +/*
|
| +** Check if the *-wal file that corresponds to the database opened by pPager
|
| +** exists if the database is not empy, or verify that the *-wal file does
|
| +** not exist (by deleting it) if the database file is empty.
|
| +**
|
| +** If the database is not empty and the *-wal file exists, open the pager
|
| +** in WAL mode. If the database is empty or if no *-wal file exists and
|
| +** if no error occurs, make sure Pager.journalMode is not set to
|
| +** PAGER_JOURNALMODE_WAL.
|
| +**
|
| +** Return SQLITE_OK or an error code.
|
| +**
|
| +** The caller must hold a SHARED lock on the database file to call this
|
| +** function. Because an EXCLUSIVE lock on the db file is required to delete
|
| +** a WAL on a none-empty database, this ensures there is no race condition
|
| +** between the xAccess() below and an xDelete() being executed by some
|
| +** other connection.
|
| +*/
|
| +static int pagerOpenWalIfPresent(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| + assert( pPager->eState==PAGER_OPEN );
|
| + assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
|
| +
|
| + if( !pPager->tempFile ){
|
| + int isWal; /* True if WAL file exists */
|
| + Pgno nPage; /* Size of the database file */
|
| +
|
| + rc = pagerPagecount(pPager, &nPage);
|
| + if( rc ) return rc;
|
| + if( nPage==0 ){
|
| + rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
|
| + isWal = 0;
|
| + }else{
|
| + rc = sqlite3OsAccess(
|
| + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
|
| + );
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + if( isWal ){
|
| + testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
|
| + rc = sqlite3PagerOpenWal(pPager, 0);
|
| + }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
|
| + pPager->journalMode = PAGER_JOURNALMODE_DELETE;
|
| + }
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +#endif
|
| +
|
| /*
|
| ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
|
| ** the entire master journal file. The case pSavepoint==NULL occurs when
|
| @@ -2098,7 +3195,8 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| int rc = SQLITE_OK; /* Return code */
|
| Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
|
|
|
| - assert( pPager->state>=PAGER_SHARED );
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| + assert( pPager->eState>=PAGER_WRITER_LOCKED );
|
|
|
| /* Allocate a bitvec to use to store the set of pages rolled back */
|
| if( pSavepoint ){
|
| @@ -2112,6 +3210,11 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| ** being reverted was opened.
|
| */
|
| pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
|
| + pPager->changeCountDone = pPager->tempFile;
|
| +
|
| + if( !pSavepoint && pagerUseWal(pPager) ){
|
| + return pagerRollbackWal(pPager);
|
| + }
|
|
|
| /* Use pPager->journalOff as the effective size of the main rollback
|
| ** journal. The actual file might be larger than this in
|
| @@ -2119,6 +3222,7 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| ** past pPager->journalOff is off-limits to us.
|
| */
|
| szJ = pPager->journalOff;
|
| + assert( pagerUseWal(pPager)==0 || szJ==0 );
|
|
|
| /* Begin by rolling back records from the main journal starting at
|
| ** PagerSavepoint.iOffset and continuing to the next journal header.
|
| @@ -2127,11 +3231,11 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| ** will be skipped automatically. Pages are added to pDone as they
|
| ** are played back.
|
| */
|
| - if( pSavepoint ){
|
| + if( pSavepoint && !pagerUseWal(pPager) ){
|
| iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
|
| pPager->journalOff = pSavepoint->iOffset;
|
| while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
|
| - rc = pager_playback_one_page(pPager, 1, 0, &pPager->journalOff, 1, pDone);
|
| + rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
|
| }
|
| assert( rc!=SQLITE_DONE );
|
| }else{
|
| @@ -2161,11 +3265,11 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
|
| }
|
| for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
|
| - rc = pager_playback_one_page(pPager, 1, 0, &pPager->journalOff, 1, pDone);
|
| + rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
|
| }
|
| assert( rc!=SQLITE_DONE );
|
| }
|
| - assert( rc!=SQLITE_OK || pPager->journalOff==szJ );
|
| + assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
|
|
|
| /* Finally, rollback pages from the sub-journal. Page that were
|
| ** previously rolled back out of the main journal (and are hence in pDone)
|
| @@ -2174,9 +3278,13 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| if( pSavepoint ){
|
| u32 ii; /* Loop counter */
|
| i64 offset = pSavepoint->iSubRec*(4+pPager->pageSize);
|
| +
|
| + if( pagerUseWal(pPager) ){
|
| + rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
|
| + }
|
| for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
|
| assert( offset==ii*(4+pPager->pageSize) );
|
| - rc = pager_playback_one_page(pPager, 0, 0, &offset, 1, pDone);
|
| + rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
|
| }
|
| assert( rc!=SQLITE_DONE );
|
| }
|
| @@ -2185,6 +3293,7 @@ static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
|
| if( rc==SQLITE_OK ){
|
| pPager->journalOff = szJ;
|
| }
|
| +
|
| return rc;
|
| }
|
|
|
| @@ -2218,15 +3327,49 @@ void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
|
| ** assurance that the journal will not be corrupted to the
|
| ** point of causing damage to the database during rollback.
|
| **
|
| +** The above is for a rollback-journal mode. For WAL mode, OFF continues
|
| +** to mean that no syncs ever occur. NORMAL means that the WAL is synced
|
| +** prior to the start of checkpoint and that the database file is synced
|
| +** at the conclusion of the checkpoint if the entire content of the WAL
|
| +** was written back into the database. But no sync operations occur for
|
| +** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
|
| +** file is synced following each commit operation, in addition to the
|
| +** syncs associated with NORMAL.
|
| +**
|
| +** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
|
| +** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
|
| +** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
|
| +** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
|
| +** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
|
| +** synchronous=FULL versus synchronous=NORMAL setting determines when
|
| +** the xSync primitive is called and is relevant to all platforms.
|
| +**
|
| ** Numeric values associated with these states are OFF==1, NORMAL=2,
|
| ** and FULL=3.
|
| */
|
| #ifndef SQLITE_OMIT_PAGER_PRAGMAS
|
| -void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int bFullFsync){
|
| +void sqlite3PagerSetSafetyLevel(
|
| + Pager *pPager, /* The pager to set safety level for */
|
| + int level, /* PRAGMA synchronous. 1=OFF, 2=NORMAL, 3=FULL */
|
| + int bFullFsync, /* PRAGMA fullfsync */
|
| + int bCkptFullFsync /* PRAGMA checkpoint_fullfsync */
|
| +){
|
| + assert( level>=1 && level<=3 );
|
| pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
|
| pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
|
| - pPager->sync_flags = (bFullFsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL);
|
| - if( pPager->noSync ) pPager->needSync = 0;
|
| + if( pPager->noSync ){
|
| + pPager->syncFlags = 0;
|
| + pPager->ckptSyncFlags = 0;
|
| + }else if( bFullFsync ){
|
| + pPager->syncFlags = SQLITE_SYNC_FULL;
|
| + pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
|
| + }else if( bCkptFullFsync ){
|
| + pPager->syncFlags = SQLITE_SYNC_NORMAL;
|
| + pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
|
| + }else{
|
| + pPager->syncFlags = SQLITE_SYNC_NORMAL;
|
| + pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
|
| + }
|
| }
|
| #endif
|
|
|
| @@ -2303,27 +3446,12 @@ void sqlite3PagerSetBusyhandler(
|
| }
|
|
|
| /*
|
| -** Report the current page size and number of reserved bytes back
|
| -** to the codec.
|
| -*/
|
| -#ifdef SQLITE_HAS_CODEC
|
| -static void pagerReportSize(Pager *pPager){
|
| - if( pPager->xCodecSizeChng ){
|
| - pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
|
| - (int)pPager->nReserve);
|
| - }
|
| -}
|
| -#else
|
| -# define pagerReportSize(X) /* No-op if we do not support a codec */
|
| -#endif
|
| -
|
| -/*
|
| ** Change the page size used by the Pager object. The new page size
|
| ** is passed in *pPageSize.
|
| **
|
| ** If the pager is in the error state when this function is called, it
|
| ** is a no-op. The value returned is the error state error code (i.e.
|
| -** one of SQLITE_IOERR, SQLITE_CORRUPT or SQLITE_FULL).
|
| +** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
|
| **
|
| ** Otherwise, if all of the following are true:
|
| **
|
| @@ -2347,28 +3475,48 @@ static void pagerReportSize(Pager *pPager){
|
| ** function was called, or because the memory allocation attempt failed,
|
| ** then *pPageSize is set to the old, retained page size before returning.
|
| */
|
| -int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize, int nReserve){
|
| - int rc = pPager->errCode;
|
| +int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
|
| + int rc = SQLITE_OK;
|
|
|
| - if( rc==SQLITE_OK ){
|
| - u16 pageSize = *pPageSize;
|
| - assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
|
| - if( (pPager->memDb==0 || pPager->dbSize==0)
|
| - && sqlite3PcacheRefCount(pPager->pPCache)==0
|
| - && pageSize && pageSize!=pPager->pageSize
|
| - ){
|
| - char *pNew = (char *)sqlite3PageMalloc(pageSize);
|
| - if( !pNew ){
|
| - rc = SQLITE_NOMEM;
|
| - }else{
|
| - pager_reset(pPager);
|
| - pPager->pageSize = pageSize;
|
| - sqlite3PageFree(pPager->pTmpSpace);
|
| - pPager->pTmpSpace = pNew;
|
| - sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
|
| - }
|
| + /* It is not possible to do a full assert_pager_state() here, as this
|
| + ** function may be called from within PagerOpen(), before the state
|
| + ** of the Pager object is internally consistent.
|
| + **
|
| + ** At one point this function returned an error if the pager was in
|
| + ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
|
| + ** there is at least one outstanding page reference, this function
|
| + ** is a no-op for that case anyhow.
|
| + */
|
| +
|
| + u32 pageSize = *pPageSize;
|
| + assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
|
| + if( (pPager->memDb==0 || pPager->dbSize==0)
|
| + && sqlite3PcacheRefCount(pPager->pPCache)==0
|
| + && pageSize && pageSize!=(u32)pPager->pageSize
|
| + ){
|
| + char *pNew = NULL; /* New temp space */
|
| + i64 nByte = 0;
|
| +
|
| + if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
|
| + rc = sqlite3OsFileSize(pPager->fd, &nByte);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + pNew = (char *)sqlite3PageMalloc(pageSize);
|
| + if( !pNew ) rc = SQLITE_NOMEM;
|
| + }
|
| +
|
| + if( rc==SQLITE_OK ){
|
| + pager_reset(pPager);
|
| + pPager->dbSize = (Pgno)(nByte/pageSize);
|
| + pPager->pageSize = pageSize;
|
| + sqlite3PageFree(pPager->pTmpSpace);
|
| + pPager->pTmpSpace = pNew;
|
| + sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
|
| }
|
| - *pPageSize = (u16)pPager->pageSize;
|
| + }
|
| +
|
| + *pPageSize = pPager->pageSize;
|
| + if( rc==SQLITE_OK ){
|
| if( nReserve<0 ) nReserve = pPager->nReserve;
|
| assert( nReserve>=0 && nReserve<1000 );
|
| pPager->nReserve = (i16)nReserve;
|
| @@ -2400,7 +3548,8 @@ int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
|
| if( mxPage>0 ){
|
| pPager->mxPgno = mxPage;
|
| }
|
| - sqlite3PagerPagecount(pPager, 0);
|
| + assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
|
| + assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
|
| return pPager->mxPgno;
|
| }
|
|
|
| @@ -2446,6 +3595,13 @@ int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
|
| int rc = SQLITE_OK;
|
| memset(pDest, 0, N);
|
| assert( isOpen(pPager->fd) || pPager->tempFile );
|
| +
|
| + /* This routine is only called by btree immediately after creating
|
| + ** the Pager object. There has not been an opportunity to transition
|
| + ** to WAL mode yet.
|
| + */
|
| + assert( !pagerUseWal(pPager) );
|
| +
|
| if( isOpen(pPager->fd) ){
|
| IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
|
| rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
|
| @@ -2457,65 +3613,16 @@ int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
|
| }
|
|
|
| /*
|
| -** Return the total number of pages in the database file associated
|
| -** with pPager. Normally, this is calculated as (<db file size>/<page-size>).
|
| +** This function may only be called when a read-transaction is open on
|
| +** the pager. It returns the total number of pages in the database.
|
| +**
|
| ** However, if the file is between 1 and <page-size> bytes in size, then
|
| ** this is considered a 1 page file.
|
| -**
|
| -** If the pager is in error state when this function is called, then the
|
| -** error state error code is returned and *pnPage left unchanged. Or,
|
| -** if the file system has to be queried for the size of the file and
|
| -** the query attempt returns an IO error, the IO error code is returned
|
| -** and *pnPage is left unchanged.
|
| -**
|
| -** Otherwise, if everything is successful, then SQLITE_OK is returned
|
| -** and *pnPage is set to the number of pages in the database.
|
| */
|
| -int sqlite3PagerPagecount(Pager *pPager, int *pnPage){
|
| - Pgno nPage; /* Value to return via *pnPage */
|
| -
|
| - /* If the pager is already in the error state, return the error code. */
|
| - if( pPager->errCode ){
|
| - return pPager->errCode;
|
| - }
|
| -
|
| - /* Determine the number of pages in the file. Store this in nPage. */
|
| - if( pPager->dbSizeValid ){
|
| - nPage = pPager->dbSize;
|
| - }else{
|
| - int rc; /* Error returned by OsFileSize() */
|
| - i64 n = 0; /* File size in bytes returned by OsFileSize() */
|
| -
|
| - assert( isOpen(pPager->fd) || pPager->tempFile );
|
| - if( isOpen(pPager->fd) && (0 != (rc = sqlite3OsFileSize(pPager->fd, &n))) ){
|
| - pager_error(pPager, rc);
|
| - return rc;
|
| - }
|
| - if( n>0 && n<pPager->pageSize ){
|
| - nPage = 1;
|
| - }else{
|
| - nPage = (Pgno)(n / pPager->pageSize);
|
| - }
|
| - if( pPager->state!=PAGER_UNLOCK ){
|
| - pPager->dbSize = nPage;
|
| - pPager->dbFileSize = nPage;
|
| - pPager->dbSizeValid = 1;
|
| - }
|
| - }
|
| -
|
| - /* If the current number of pages in the file is greater than the
|
| - ** configured maximum pager number, increase the allowed limit so
|
| - ** that the file can be read.
|
| - */
|
| - if( nPage>pPager->mxPgno ){
|
| - pPager->mxPgno = (Pgno)nPage;
|
| - }
|
| -
|
| - /* Set the output variable and return SQLITE_OK */
|
| - if( pnPage ){
|
| - *pnPage = nPage;
|
| - }
|
| - return SQLITE_OK;
|
| +void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
|
| + assert( pPager->eState>=PAGER_READER );
|
| + assert( pPager->eState!=PAGER_WRITER_FINISHED );
|
| + *pnPage = (int)pPager->dbSize;
|
| }
|
|
|
|
|
| @@ -2536,35 +3643,19 @@ int sqlite3PagerPagecount(Pager *pPager, int *pnPage){
|
| static int pager_wait_on_lock(Pager *pPager, int locktype){
|
| int rc; /* Return code */
|
|
|
| - /* The OS lock values must be the same as the Pager lock values */
|
| - assert( PAGER_SHARED==SHARED_LOCK );
|
| - assert( PAGER_RESERVED==RESERVED_LOCK );
|
| - assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK );
|
| -
|
| - /* If the file is currently unlocked then the size must be unknown */
|
| - assert( pPager->state>=PAGER_SHARED || pPager->dbSizeValid==0 );
|
| -
|
| /* Check that this is either a no-op (because the requested lock is
|
| ** already held, or one of the transistions that the busy-handler
|
| ** may be invoked during, according to the comment above
|
| ** sqlite3PagerSetBusyhandler().
|
| */
|
| - assert( (pPager->state>=locktype)
|
| - || (pPager->state==PAGER_UNLOCK && locktype==PAGER_SHARED)
|
| - || (pPager->state==PAGER_RESERVED && locktype==PAGER_EXCLUSIVE)
|
| + assert( (pPager->eLock>=locktype)
|
| + || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
|
| + || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
|
| );
|
|
|
| - if( pPager->state>=locktype ){
|
| - rc = SQLITE_OK;
|
| - }else{
|
| - do {
|
| - rc = sqlite3OsLock(pPager->fd, locktype);
|
| - }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
|
| - if( rc==SQLITE_OK ){
|
| - pPager->state = (u8)locktype;
|
| - IOTRACE(("LOCK %p %d\n", pPager, locktype))
|
| - }
|
| - }
|
| + do {
|
| + rc = pagerLockDb(pPager, locktype);
|
| + }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
|
| return rc;
|
| }
|
|
|
| @@ -2609,13 +3700,38 @@ static void assertTruncateConstraint(Pager *pPager){
|
| ** truncation will be done when the current transaction is committed.
|
| */
|
| void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
|
| - assert( pPager->dbSizeValid );
|
| assert( pPager->dbSize>=nPage );
|
| - assert( pPager->state>=PAGER_RESERVED );
|
| + assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
|
| pPager->dbSize = nPage;
|
| assertTruncateConstraint(pPager);
|
| }
|
|
|
| +
|
| +/*
|
| +** This function is called before attempting a hot-journal rollback. It
|
| +** syncs the journal file to disk, then sets pPager->journalHdr to the
|
| +** size of the journal file so that the pager_playback() routine knows
|
| +** that the entire journal file has been synced.
|
| +**
|
| +** Syncing a hot-journal to disk before attempting to roll it back ensures
|
| +** that if a power-failure occurs during the rollback, the process that
|
| +** attempts rollback following system recovery sees the same journal
|
| +** content as this process.
|
| +**
|
| +** If everything goes as planned, SQLITE_OK is returned. Otherwise,
|
| +** an SQLite error code.
|
| +*/
|
| +static int pagerSyncHotJournal(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| + if( !pPager->noSync ){
|
| + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| /*
|
| ** Shutdown the page cache. Free all memory and close all files.
|
| **
|
| @@ -2631,29 +3747,43 @@ void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
|
| ** to the caller.
|
| */
|
| int sqlite3PagerClose(Pager *pPager){
|
| + u8 *pTmp = (u8 *)pPager->pTmpSpace;
|
| +
|
| disable_simulated_io_errors();
|
| sqlite3BeginBenignMalloc();
|
| - pPager->errCode = 0;
|
| + /* pPager->errCode = 0; */
|
| pPager->exclusiveMode = 0;
|
| +#ifndef SQLITE_OMIT_WAL
|
| + sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
|
| + pPager->pWal = 0;
|
| +#endif
|
| pager_reset(pPager);
|
| if( MEMDB ){
|
| pager_unlock(pPager);
|
| }else{
|
| - /* Set Pager.journalHdr to -1 for the benefit of the pager_playback()
|
| - ** call which may be made from within pagerUnlockAndRollback(). If it
|
| - ** is not -1, then the unsynced portion of an open journal file may
|
| - ** be played back into the database. If a power failure occurs while
|
| - ** this is happening, the database may become corrupt.
|
| + /* If it is open, sync the journal file before calling UnlockAndRollback.
|
| + ** If this is not done, then an unsynced portion of the open journal
|
| + ** file may be played back into the database. If a power failure occurs
|
| + ** while this is happening, the database could become corrupt.
|
| + **
|
| + ** If an error occurs while trying to sync the journal, shift the pager
|
| + ** into the ERROR state. This causes UnlockAndRollback to unlock the
|
| + ** database and close the journal file without attempting to roll it
|
| + ** back or finalize it. The next database user will have to do hot-journal
|
| + ** rollback before accessing the database file.
|
| */
|
| - pPager->journalHdr = -1;
|
| + if( isOpen(pPager->jfd) ){
|
| + pager_error(pPager, pagerSyncHotJournal(pPager));
|
| + }
|
| pagerUnlockAndRollback(pPager);
|
| }
|
| sqlite3EndBenignMalloc();
|
| enable_simulated_io_errors();
|
| PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
|
| IOTRACE(("CLOSE %p\n", pPager))
|
| + sqlite3OsClose(pPager->jfd);
|
| sqlite3OsClose(pPager->fd);
|
| - sqlite3PageFree(pPager->pTmpSpace);
|
| + sqlite3PageFree(pTmp);
|
| sqlite3PcacheClose(pPager->pPCache);
|
|
|
| #ifdef SQLITE_HAS_CODEC
|
| @@ -2688,9 +3818,9 @@ void sqlite3PagerRef(DbPage *pPg){
|
| ** been written to the journal have actually reached the surface of the
|
| ** disk and can be restored in the event of a hot-journal rollback.
|
| **
|
| -** If the Pager.needSync flag is not set, then this function is a
|
| -** no-op. Otherwise, the actions required depend on the journal-mode
|
| -** and the device characteristics of the the file-system, as follows:
|
| +** If the Pager.noSync flag is set, then this function is a no-op.
|
| +** Otherwise, the actions required depend on the journal-mode and the
|
| +** device characteristics of the the file-system, as follows:
|
| **
|
| ** * If the journal file is an in-memory journal file, no action need
|
| ** be taken.
|
| @@ -2714,18 +3844,25 @@ void sqlite3PagerRef(DbPage *pPg){
|
| ** if( NOT SEQUENTIAL ) xSync(<journal file>);
|
| ** }
|
| **
|
| -** The Pager.needSync flag is never be set for temporary files, or any
|
| -** file operating in no-sync mode (Pager.noSync set to non-zero).
|
| -**
|
| ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
|
| ** page currently held in memory before returning SQLITE_OK. If an IO
|
| ** error is encountered, then the IO error code is returned to the caller.
|
| */
|
| -static int syncJournal(Pager *pPager){
|
| - if( pPager->needSync ){
|
| +static int syncJournal(Pager *pPager, int newHdr){
|
| + int rc; /* Return code */
|
| +
|
| + assert( pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
| + assert( !pagerUseWal(pPager) );
|
| +
|
| + rc = sqlite3PagerExclusiveLock(pPager);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + if( !pPager->noSync ){
|
| assert( !pPager->tempFile );
|
| - if( pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
|
| - int rc; /* Return code */
|
| + if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
|
| const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
|
| assert( isOpen(pPager->jfd) );
|
|
|
| @@ -2735,7 +3872,7 @@ static int syncJournal(Pager *pPager){
|
| ** mode, then the journal file may at this point actually be larger
|
| ** than Pager.journalOff bytes. If the next thing in the journal
|
| ** file happens to be a journal-header (written as part of the
|
| - ** previous connections transaction), and a crash or power-failure
|
| + ** previous connection's transaction), and a crash or power-failure
|
| ** occurs after nRec is updated but before this connection writes
|
| ** anything else to the journal file (or commits/rolls back its
|
| ** transaction), then SQLite may become confused when doing the
|
| @@ -2754,10 +3891,10 @@ static int syncJournal(Pager *pPager){
|
| */
|
| i64 iNextHdrOffset;
|
| u8 aMagic[8];
|
| - u8 zHeader[sizeof(aJournalMagic)+4];
|
| + u8 zHeader[sizeof(aJournalMagic)+4];
|
|
|
| - memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
|
| - put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
|
| + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
|
| + put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
|
|
|
| iNextHdrOffset = journalHdrOffset(pPager);
|
| rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
|
| @@ -2783,33 +3920,42 @@ static int syncJournal(Pager *pPager){
|
| if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
|
| PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
|
| IOTRACE(("JSYNC %p\n", pPager))
|
| - rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags);
|
| + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
|
| if( rc!=SQLITE_OK ) return rc;
|
| }
|
| IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
|
| rc = sqlite3OsWrite(
|
| pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
|
| - );
|
| + );
|
| if( rc!=SQLITE_OK ) return rc;
|
| }
|
| if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
|
| PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
|
| IOTRACE(("JSYNC %p\n", pPager))
|
| - rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags|
|
| - (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
|
| + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
|
| + (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
|
| );
|
| if( rc!=SQLITE_OK ) return rc;
|
| }
|
| - }
|
|
|
| - /* The journal file was just successfully synced. Set Pager.needSync
|
| - ** to zero and clear the PGHDR_NEED_SYNC flag on all pagess.
|
| - */
|
| - pPager->needSync = 0;
|
| - pPager->journalStarted = 1;
|
| - sqlite3PcacheClearSyncFlags(pPager->pPCache);
|
| + pPager->journalHdr = pPager->journalOff;
|
| + if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
|
| + pPager->nRec = 0;
|
| + rc = writeJournalHdr(pPager);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| + }
|
| + }else{
|
| + pPager->journalHdr = pPager->journalOff;
|
| + }
|
| }
|
|
|
| + /* Unless the pager is in noSync mode, the journal file was just
|
| + ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
|
| + ** all pages.
|
| + */
|
| + sqlite3PcacheClearSyncFlags(pPager->pPCache);
|
| + pPager->eState = PAGER_WRITER_DBMOD;
|
| + assert( assert_pager_state(pPager) );
|
| return SQLITE_OK;
|
| }
|
|
|
| @@ -2845,31 +3991,13 @@ static int syncJournal(Pager *pPager){
|
| ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
|
| ** be obtained, SQLITE_BUSY is returned.
|
| */
|
| -static int pager_write_pagelist(PgHdr *pList){
|
| - Pager *pPager; /* Pager object */
|
| - int rc; /* Return code */
|
| -
|
| - if( NEVER(pList==0) ) return SQLITE_OK;
|
| - pPager = pList->pPager;
|
| +static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
|
| + int rc = SQLITE_OK; /* Return code */
|
|
|
| - /* At this point there may be either a RESERVED or EXCLUSIVE lock on the
|
| - ** database file. If there is already an EXCLUSIVE lock, the following
|
| - ** call is a no-op.
|
| - **
|
| - ** Moving the lock from RESERVED to EXCLUSIVE actually involves going
|
| - ** through an intermediate state PENDING. A PENDING lock prevents new
|
| - ** readers from attaching to the database but is unsufficient for us to
|
| - ** write. The idea of a PENDING lock is to prevent new readers from
|
| - ** coming in while we wait for existing readers to clear.
|
| - **
|
| - ** While the pager is in the RESERVED state, the original database file
|
| - ** is unchanged and we can rollback without having to playback the
|
| - ** journal into the original database file. Once we transition to
|
| - ** EXCLUSIVE, it means the database file has been changed and any rollback
|
| - ** will require a journal playback.
|
| - */
|
| - assert( pPager->state>=PAGER_RESERVED );
|
| - rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
|
| + /* This function is only called for rollback pagers in WRITER_DBMOD state. */
|
| + assert( !pagerUseWal(pPager) );
|
| + assert( pPager->eState==PAGER_WRITER_DBMOD );
|
| + assert( pPager->eLock==EXCLUSIVE_LOCK );
|
|
|
| /* If the file is a temp-file has not yet been opened, open it now. It
|
| ** is not possible for rc to be other than SQLITE_OK if this branch
|
| @@ -2880,6 +4008,16 @@ static int pager_write_pagelist(PgHdr *pList){
|
| rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
|
| }
|
|
|
| + /* Before the first write, give the VFS a hint of what the final
|
| + ** file size will be.
|
| + */
|
| + assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
|
| + if( rc==SQLITE_OK && pPager->dbSize>pPager->dbHintSize ){
|
| + sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
|
| + sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
|
| + pPager->dbHintSize = pPager->dbSize;
|
| + }
|
| +
|
| while( rc==SQLITE_OK && pList ){
|
| Pgno pgno = pList->pgno;
|
|
|
| @@ -2895,6 +4033,9 @@ static int pager_write_pagelist(PgHdr *pList){
|
| i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
|
| char *pData; /* Data to write */
|
|
|
| + assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
|
| + if( pList->pgno==1 ) pager_write_changecounter(pList);
|
| +
|
| /* Encode the database */
|
| CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
|
|
|
| @@ -2923,9 +4064,7 @@ static int pager_write_pagelist(PgHdr *pList){
|
| }else{
|
| PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
|
| }
|
| -#ifdef SQLITE_CHECK_PAGES
|
| - pList->pageHash = pager_pagehash(pList);
|
| -#endif
|
| + pager_set_pagehash(pList);
|
| pList = pList->pDirty;
|
| }
|
|
|
| @@ -2933,6 +4072,26 @@ static int pager_write_pagelist(PgHdr *pList){
|
| }
|
|
|
| /*
|
| +** Ensure that the sub-journal file is open. If it is already open, this
|
| +** function is a no-op.
|
| +**
|
| +** SQLITE_OK is returned if everything goes according to plan. An
|
| +** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
|
| +** fails.
|
| +*/
|
| +static int openSubJournal(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| + if( !isOpen(pPager->sjfd) ){
|
| + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
|
| + sqlite3MemJournalOpen(pPager->sjfd);
|
| + }else{
|
| + rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| ** Append a record of the current state of page pPg to the sub-journal.
|
| ** It is the callers responsibility to use subjRequiresPage() to check
|
| ** that it is really required before calling this function.
|
| @@ -2948,18 +4107,31 @@ static int pager_write_pagelist(PgHdr *pList){
|
| static int subjournalPage(PgHdr *pPg){
|
| int rc = SQLITE_OK;
|
| Pager *pPager = pPg->pPager;
|
| - if( isOpen(pPager->sjfd) ){
|
| - void *pData = pPg->pData;
|
| - i64 offset = pPager->nSubRec*(4+pPager->pageSize);
|
| - char *pData2;
|
| + if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
|
| +
|
| + /* Open the sub-journal, if it has not already been opened */
|
| + assert( pPager->useJournal );
|
| + assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
|
| + assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
|
| + assert( pagerUseWal(pPager)
|
| + || pageInJournal(pPg)
|
| + || pPg->pgno>pPager->dbOrigSize
|
| + );
|
| + rc = openSubJournal(pPager);
|
|
|
| - CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
|
| - PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
|
| -
|
| - assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
|
| - rc = write32bits(pPager->sjfd, offset, pPg->pgno);
|
| + /* If the sub-journal was opened successfully (or was already open),
|
| + ** write the journal record into the file. */
|
| if( rc==SQLITE_OK ){
|
| - rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
|
| + void *pData = pPg->pData;
|
| + i64 offset = pPager->nSubRec*(4+pPager->pageSize);
|
| + char *pData2;
|
| +
|
| + CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
|
| + PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
|
| + rc = write32bits(pPager->sjfd, offset, pPg->pgno);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
|
| + }
|
| }
|
| }
|
| if( rc==SQLITE_OK ){
|
| @@ -2970,7 +4142,6 @@ static int subjournalPage(PgHdr *pPg){
|
| return rc;
|
| }
|
|
|
| -
|
| /*
|
| ** This function is called by the pcache layer when it has reached some
|
| ** soft memory limit. The first argument is a pointer to a Pager object
|
| @@ -2997,74 +4168,83 @@ static int pagerStress(void *p, PgHdr *pPg){
|
| assert( pPg->pPager==pPager );
|
| assert( pPg->flags&PGHDR_DIRTY );
|
|
|
| - /* The doNotSync flag is set by the sqlite3PagerWrite() function while it
|
| - ** is journalling a set of two or more database pages that are stored
|
| - ** on the same disk sector. Syncing the journal is not allowed while
|
| - ** this is happening as it is important that all members of such a
|
| - ** set of pages are synced to disk together. So, if the page this function
|
| - ** is trying to make clean will require a journal sync and the doNotSync
|
| - ** flag is set, return without doing anything. The pcache layer will
|
| - ** just have to go ahead and allocate a new page buffer instead of
|
| - ** reusing pPg.
|
| + /* The doNotSyncSpill flag is set during times when doing a sync of
|
| + ** journal (and adding a new header) is not allowed. This occurs
|
| + ** during calls to sqlite3PagerWrite() while trying to journal multiple
|
| + ** pages belonging to the same sector.
|
| + **
|
| + ** The doNotSpill flag inhibits all cache spilling regardless of whether
|
| + ** or not a sync is required. This is set during a rollback.
|
| **
|
| - ** Similarly, if the pager has already entered the error state, do not
|
| - ** try to write the contents of pPg to disk.
|
| + ** Spilling is also prohibited when in an error state since that could
|
| + ** lead to database corruption. In the current implementaton it
|
| + ** is impossible for sqlite3PCacheFetch() to be called with createFlag==1
|
| + ** while in the error state, hence it is impossible for this routine to
|
| + ** be called in the error state. Nevertheless, we include a NEVER()
|
| + ** test for the error state as a safeguard against future changes.
|
| */
|
| - if( NEVER(pPager->errCode)
|
| - || (pPager->doNotSync && pPg->flags&PGHDR_NEED_SYNC)
|
| - ){
|
| + if( NEVER(pPager->errCode) ) return SQLITE_OK;
|
| + if( pPager->doNotSpill ) return SQLITE_OK;
|
| + if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
|
| return SQLITE_OK;
|
| }
|
|
|
| - /* Sync the journal file if required. */
|
| - if( pPg->flags&PGHDR_NEED_SYNC ){
|
| - rc = syncJournal(pPager);
|
| - if( rc==SQLITE_OK && pPager->fullSync &&
|
| - !(pPager->journalMode==PAGER_JOURNALMODE_MEMORY) &&
|
| - !(sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
|
| + pPg->pDirty = 0;
|
| + if( pagerUseWal(pPager) ){
|
| + /* Write a single frame for this page to the log. */
|
| + if( subjRequiresPage(pPg) ){
|
| + rc = subjournalPage(pPg);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + rc = pagerWalFrames(pPager, pPg, 0, 0, 0);
|
| + }
|
| + }else{
|
| +
|
| + /* Sync the journal file if required. */
|
| + if( pPg->flags&PGHDR_NEED_SYNC
|
| + || pPager->eState==PAGER_WRITER_CACHEMOD
|
| ){
|
| - pPager->nRec = 0;
|
| - rc = writeJournalHdr(pPager);
|
| + rc = syncJournal(pPager, 1);
|
| + }
|
| +
|
| + /* If the page number of this page is larger than the current size of
|
| + ** the database image, it may need to be written to the sub-journal.
|
| + ** This is because the call to pager_write_pagelist() below will not
|
| + ** actually write data to the file in this case.
|
| + **
|
| + ** Consider the following sequence of events:
|
| + **
|
| + ** BEGIN;
|
| + ** <journal page X>
|
| + ** <modify page X>
|
| + ** SAVEPOINT sp;
|
| + ** <shrink database file to Y pages>
|
| + ** pagerStress(page X)
|
| + ** ROLLBACK TO sp;
|
| + **
|
| + ** If (X>Y), then when pagerStress is called page X will not be written
|
| + ** out to the database file, but will be dropped from the cache. Then,
|
| + ** following the "ROLLBACK TO sp" statement, reading page X will read
|
| + ** data from the database file. This will be the copy of page X as it
|
| + ** was when the transaction started, not as it was when "SAVEPOINT sp"
|
| + ** was executed.
|
| + **
|
| + ** The solution is to write the current data for page X into the
|
| + ** sub-journal file now (if it is not already there), so that it will
|
| + ** be restored to its current value when the "ROLLBACK TO sp" is
|
| + ** executed.
|
| + */
|
| + if( NEVER(
|
| + rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
|
| + ) ){
|
| + rc = subjournalPage(pPg);
|
| + }
|
| +
|
| + /* Write the contents of the page out to the database file. */
|
| + if( rc==SQLITE_OK ){
|
| + assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
|
| + rc = pager_write_pagelist(pPager, pPg);
|
| }
|
| - }
|
| -
|
| - /* If the page number of this page is larger than the current size of
|
| - ** the database image, it may need to be written to the sub-journal.
|
| - ** This is because the call to pager_write_pagelist() below will not
|
| - ** actually write data to the file in this case.
|
| - **
|
| - ** Consider the following sequence of events:
|
| - **
|
| - ** BEGIN;
|
| - ** <journal page X>
|
| - ** <modify page X>
|
| - ** SAVEPOINT sp;
|
| - ** <shrink database file to Y pages>
|
| - ** pagerStress(page X)
|
| - ** ROLLBACK TO sp;
|
| - **
|
| - ** If (X>Y), then when pagerStress is called page X will not be written
|
| - ** out to the database file, but will be dropped from the cache. Then,
|
| - ** following the "ROLLBACK TO sp" statement, reading page X will read
|
| - ** data from the database file. This will be the copy of page X as it
|
| - ** was when the transaction started, not as it was when "SAVEPOINT sp"
|
| - ** was executed.
|
| - **
|
| - ** The solution is to write the current data for page X into the
|
| - ** sub-journal file now (if it is not already there), so that it will
|
| - ** be restored to its current value when the "ROLLBACK TO sp" is
|
| - ** executed.
|
| - */
|
| - if( NEVER(
|
| - rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
|
| - ) ){
|
| - rc = subjournalPage(pPg);
|
| - }
|
| -
|
| - /* Write the contents of the page out to the database file. */
|
| - if( rc==SQLITE_OK ){
|
| - pPg->pDirty = 0;
|
| - rc = pager_write_pagelist(pPg);
|
| }
|
|
|
| /* Mark the page as clean. */
|
| @@ -3073,7 +4253,7 @@ static int pagerStress(void *p, PgHdr *pPg){
|
| sqlite3PcacheMakeClean(pPg);
|
| }
|
|
|
| - return pager_error(pPager, rc);
|
| + return pager_error(pPager, rc);
|
| }
|
|
|
|
|
| @@ -3128,7 +4308,7 @@ int sqlite3PagerOpen(
|
| int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
|
| int noReadlock = (flags & PAGER_NO_READLOCK)!=0; /* True to omit read-lock */
|
| int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
|
| - u16 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
|
| + u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
|
|
|
| /* Figure out how much space is required for each journal file-handle
|
| ** (there are two of them, the main journal and the sub-journal). This
|
| @@ -3147,6 +4327,13 @@ int sqlite3PagerOpen(
|
| /* Set the output variable to NULL in case an error occurs. */
|
| *ppPager = 0;
|
|
|
| +#ifndef SQLITE_OMIT_MEMORYDB
|
| + if( flags & PAGER_MEMORY ){
|
| + memDb = 1;
|
| + zFilename = 0;
|
| + }
|
| +#endif
|
| +
|
| /* Compute and store the full pathname in an allocated buffer pointed
|
| ** to by zPathname, length nPathname. Or, if this is a temporary file,
|
| ** leave both nPathname and zPathname set to 0.
|
| @@ -3157,17 +4344,8 @@ int sqlite3PagerOpen(
|
| if( zPathname==0 ){
|
| return SQLITE_NOMEM;
|
| }
|
| -#ifndef SQLITE_OMIT_MEMORYDB
|
| - if( strcmp(zFilename,":memory:")==0 ){
|
| - memDb = 1;
|
| - zPathname[0] = 0;
|
| - }else
|
| -#endif
|
| - {
|
| - zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
|
| - rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
|
| - }
|
| -
|
| + zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
|
| + rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
|
| nPathname = sqlite3Strlen30(zPathname);
|
| if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
|
| /* This branch is taken when the journal path required by
|
| @@ -3176,7 +4354,7 @@ int sqlite3PagerOpen(
|
| ** as it will not be possible to open the journal file or even
|
| ** check for a hot-journal before reading.
|
| */
|
| - rc = SQLITE_CANTOPEN;
|
| + rc = SQLITE_CANTOPEN_BKPT;
|
| }
|
| if( rc!=SQLITE_OK ){
|
| sqlite3_free(zPathname);
|
| @@ -3203,6 +4381,9 @@ int sqlite3PagerOpen(
|
| journalFileSize * 2 + /* The two journal files */
|
| nPathname + 1 + /* zFilename */
|
| nPathname + 8 + 1 /* zJournal */
|
| +#ifndef SQLITE_OMIT_WAL
|
| + + nPathname + 4 + 1 /* zWal */
|
| +#endif
|
| );
|
| assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
|
| if( !pPtr ){
|
| @@ -3219,11 +4400,16 @@ int sqlite3PagerOpen(
|
|
|
| /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
|
| if( zPathname ){
|
| + assert( nPathname>0 );
|
| pPager->zJournal = (char*)(pPtr += nPathname + 1);
|
| memcpy(pPager->zFilename, zPathname, nPathname);
|
| memcpy(pPager->zJournal, zPathname, nPathname);
|
| memcpy(&pPager->zJournal[nPathname], "-journal", 8);
|
| - if( pPager->zFilename[0]==0 ) pPager->zJournal[0] = 0;
|
| +#ifndef SQLITE_OMIT_WAL
|
| + pPager->zWal = &pPager->zJournal[nPathname+8+1];
|
| + memcpy(pPager->zWal, zPathname, nPathname);
|
| + memcpy(&pPager->zWal[nPathname], "-wal", 4);
|
| +#endif
|
| sqlite3_free(zPathname);
|
| }
|
| pPager->pVfs = pVfs;
|
| @@ -3231,9 +4417,10 @@ int sqlite3PagerOpen(
|
|
|
| /* Open the pager file.
|
| */
|
| - if( zFilename && zFilename[0] && !memDb ){
|
| + if( zFilename && zFilename[0] ){
|
| int fout = 0; /* VFS flags returned by xOpen() */
|
| rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
|
| + assert( !memDb );
|
| readOnly = (fout&SQLITE_OPEN_READONLY);
|
|
|
| /* If the file was successfully opened for read/write access,
|
| @@ -3251,7 +4438,7 @@ int sqlite3PagerOpen(
|
| if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
|
| szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
|
| }else{
|
| - szPageDflt = (u16)pPager->sectorSize;
|
| + szPageDflt = (u32)pPager->sectorSize;
|
| }
|
| }
|
| #ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| @@ -3279,7 +4466,8 @@ int sqlite3PagerOpen(
|
| ** disk and uses an in-memory rollback journal.
|
| */
|
| tempFile = 1;
|
| - pPager->state = PAGER_EXCLUSIVE;
|
| + pPager->eState = PAGER_READER;
|
| + pPager->eLock = EXCLUSIVE_LOCK;
|
| readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
|
| }
|
|
|
| @@ -3316,13 +4504,14 @@ int sqlite3PagerOpen(
|
| /* pPager->stmtOpen = 0; */
|
| /* pPager->stmtInUse = 0; */
|
| /* pPager->nRef = 0; */
|
| - pPager->dbSizeValid = (u8)memDb;
|
| /* pPager->stmtSize = 0; */
|
| /* pPager->stmtJSize = 0; */
|
| /* pPager->nPage = 0; */
|
| pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
|
| /* pPager->state = PAGER_UNLOCK; */
|
| +#if 0
|
| assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
|
| +#endif
|
| /* pPager->errMask = 0; */
|
| pPager->tempFile = (u8)tempFile;
|
| assert( tempFile==PAGER_LOCKINGMODE_NORMAL
|
| @@ -3332,11 +4521,11 @@ int sqlite3PagerOpen(
|
| pPager->changeCountDone = pPager->tempFile;
|
| pPager->memDb = (u8)memDb;
|
| pPager->readOnly = (u8)readOnly;
|
| - /* pPager->needSync = 0; */
|
| assert( useJournal || pPager->tempFile );
|
| pPager->noSync = pPager->tempFile;
|
| pPager->fullSync = pPager->noSync ?0:1;
|
| - pPager->sync_flags = SQLITE_SYNC_NORMAL;
|
| + pPager->syncFlags = pPager->noSync ? 0 : SQLITE_SYNC_NORMAL;
|
| + pPager->ckptSyncFlags = pPager->syncFlags;
|
| /* pPager->pFirst = 0; */
|
| /* pPager->pFirstSynced = 0; */
|
| /* pPager->pLast = 0; */
|
| @@ -3353,6 +4542,7 @@ int sqlite3PagerOpen(
|
| /* pPager->pBusyHandlerArg = 0; */
|
| pPager->xReiniter = xReinit;
|
| /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
|
| +
|
| *ppPager = pPager;
|
| return SQLITE_OK;
|
| }
|
| @@ -3392,19 +4582,24 @@ int sqlite3PagerOpen(
|
| */
|
| static int hasHotJournal(Pager *pPager, int *pExists){
|
| sqlite3_vfs * const pVfs = pPager->pVfs;
|
| - int rc; /* Return code */
|
| - int exists; /* True if a journal file is present */
|
| + int rc = SQLITE_OK; /* Return code */
|
| + int exists = 1; /* True if a journal file is present */
|
| + int jrnlOpen = !!isOpen(pPager->jfd);
|
|
|
| - assert( pPager!=0 );
|
| assert( pPager->useJournal );
|
| assert( isOpen(pPager->fd) );
|
| - assert( !isOpen(pPager->jfd) );
|
| - assert( pPager->state <= PAGER_SHARED );
|
| + assert( pPager->eState==PAGER_OPEN );
|
| +
|
| + assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
|
| + SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
|
| + ));
|
|
|
| *pExists = 0;
|
| - rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
|
| + if( !jrnlOpen ){
|
| + rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
|
| + }
|
| if( rc==SQLITE_OK && exists ){
|
| - int locked; /* True if some process holds a RESERVED lock */
|
| + int locked = 0; /* True if some process holds a RESERVED lock */
|
|
|
| /* Race condition here: Another process might have been holding the
|
| ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
|
| @@ -3416,7 +4611,7 @@ static int hasHotJournal(Pager *pPager, int *pExists){
|
| */
|
| rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
|
| if( rc==SQLITE_OK && !locked ){
|
| - int nPage;
|
| + Pgno nPage; /* Number of pages in database file */
|
|
|
| /* Check the size of the database file. If it consists of 0 pages,
|
| ** then delete the journal file. See the header comment above for
|
| @@ -3424,13 +4619,13 @@ static int hasHotJournal(Pager *pPager, int *pExists){
|
| ** a RESERVED lock to avoid race conditions and to avoid violating
|
| ** [H33020].
|
| */
|
| - rc = sqlite3PagerPagecount(pPager, &nPage);
|
| + rc = pagerPagecount(pPager, &nPage);
|
| if( rc==SQLITE_OK ){
|
| if( nPage==0 ){
|
| sqlite3BeginBenignMalloc();
|
| - if( sqlite3OsLock(pPager->fd, RESERVED_LOCK)==SQLITE_OK ){
|
| + if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
|
| sqlite3OsDelete(pVfs, pPager->zJournal, 0);
|
| - sqlite3OsUnlock(pPager->fd, SHARED_LOCK);
|
| + if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
|
| }
|
| sqlite3EndBenignMalloc();
|
| }else{
|
| @@ -3440,15 +4635,19 @@ static int hasHotJournal(Pager *pPager, int *pExists){
|
| ** If there is, then we consider this journal to be hot. If not,
|
| ** it can be ignored.
|
| */
|
| - int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
|
| - rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
|
| + if( !jrnlOpen ){
|
| + int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
|
| + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
|
| + }
|
| if( rc==SQLITE_OK ){
|
| u8 first = 0;
|
| rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
|
| if( rc==SQLITE_IOERR_SHORT_READ ){
|
| rc = SQLITE_OK;
|
| }
|
| - sqlite3OsClose(pPager->jfd);
|
| + if( !jrnlOpen ){
|
| + sqlite3OsClose(pPager->jfd);
|
| + }
|
| *pExists = (first!=0);
|
| }else if( rc==SQLITE_CANTOPEN ){
|
| /* If we cannot open the rollback journal file in order to see if
|
| @@ -3472,51 +4671,6 @@ static int hasHotJournal(Pager *pPager, int *pExists){
|
| }
|
|
|
| /*
|
| -** Read the content for page pPg out of the database file and into
|
| -** pPg->pData. A shared lock or greater must be held on the database
|
| -** file before this function is called.
|
| -**
|
| -** If page 1 is read, then the value of Pager.dbFileVers[] is set to
|
| -** the value read from the database file.
|
| -**
|
| -** If an IO error occurs, then the IO error is returned to the caller.
|
| -** Otherwise, SQLITE_OK is returned.
|
| -*/
|
| -static int readDbPage(PgHdr *pPg){
|
| - Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
|
| - Pgno pgno = pPg->pgno; /* Page number to read */
|
| - int rc; /* Return code */
|
| - i64 iOffset; /* Byte offset of file to read from */
|
| -
|
| - assert( pPager->state>=PAGER_SHARED && !MEMDB );
|
| - assert( isOpen(pPager->fd) );
|
| -
|
| - if( NEVER(!isOpen(pPager->fd)) ){
|
| - assert( pPager->tempFile );
|
| - memset(pPg->pData, 0, pPager->pageSize);
|
| - return SQLITE_OK;
|
| - }
|
| - iOffset = (pgno-1)*(i64)pPager->pageSize;
|
| - rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset);
|
| - if( rc==SQLITE_IOERR_SHORT_READ ){
|
| - rc = SQLITE_OK;
|
| - }
|
| - if( pgno==1 ){
|
| - u8 *dbFileVers = &((u8*)pPg->pData)[24];
|
| - memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
|
| - }
|
| - CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
|
| -
|
| - PAGER_INCR(sqlite3_pager_readdb_count);
|
| - PAGER_INCR(pPager->nRead);
|
| - IOTRACE(("PGIN %p %d\n", pPager, pgno));
|
| - PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
|
| - PAGERID(pPager), pgno, pager_pagehash(pPg)));
|
| -
|
| - return rc;
|
| -}
|
| -
|
| -/*
|
| ** This function is called to obtain a shared lock on the database file.
|
| ** It is illegal to call sqlite3PagerAcquire() until after this function
|
| ** has been successfully called. If a shared-lock is already held when
|
| @@ -3524,7 +4678,7 @@ static int readDbPage(PgHdr *pPg){
|
| **
|
| ** The following operations are also performed by this function.
|
| **
|
| -** 1) If the pager is currently in PAGER_UNLOCK state (no lock held
|
| +** 1) If the pager is currently in PAGER_OPEN state (no lock held
|
| ** on the database file), then an attempt is made to obtain a
|
| ** SHARED lock on the database file. Immediately after obtaining
|
| ** the SHARED lock, the file-system is checked for a hot-journal,
|
| @@ -3539,64 +4693,47 @@ static int readDbPage(PgHdr *pPg){
|
| ** the contents of the page cache and rolling back any open journal
|
| ** file.
|
| **
|
| -** If the operation described by (2) above is not attempted, and if the
|
| -** pager is in an error state other than SQLITE_FULL when this is called,
|
| -** the error state error code is returned. It is permitted to read the
|
| -** database when in SQLITE_FULL error state.
|
| -**
|
| -** Otherwise, if everything is successful, SQLITE_OK is returned. If an
|
| -** IO error occurs while locking the database, checking for a hot-journal
|
| -** file or rolling back a journal file, the IO error code is returned.
|
| +** If everything is successful, SQLITE_OK is returned. If an IO error
|
| +** occurs while locking the database, checking for a hot-journal file or
|
| +** rolling back a journal file, the IO error code is returned.
|
| */
|
| int sqlite3PagerSharedLock(Pager *pPager){
|
| int rc = SQLITE_OK; /* Return code */
|
| - int isErrorReset = 0; /* True if recovering from error state */
|
|
|
| /* This routine is only called from b-tree and only when there are no
|
| - ** outstanding pages */
|
| + ** outstanding pages. This implies that the pager state should either
|
| + ** be OPEN or READER. READER is only possible if the pager is or was in
|
| + ** exclusive access mode.
|
| + */
|
| assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
|
| + assert( assert_pager_state(pPager) );
|
| + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
|
| if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
|
|
|
| - /* If this database is in an error-state, now is a chance to clear
|
| - ** the error. Discard the contents of the pager-cache and rollback
|
| - ** any hot journal in the file-system.
|
| - */
|
| - if( pPager->errCode ){
|
| - if( isOpen(pPager->jfd) || pPager->zJournal ){
|
| - isErrorReset = 1;
|
| - }
|
| - pPager->errCode = SQLITE_OK;
|
| - pager_reset(pPager);
|
| - }
|
| + if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
|
| + int bHotJournal = 1; /* True if there exists a hot journal-file */
|
|
|
| - if( pPager->state==PAGER_UNLOCK || isErrorReset ){
|
| - sqlite3_vfs * const pVfs = pPager->pVfs;
|
| - int isHotJournal = 0;
|
| assert( !MEMDB );
|
| - assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
|
| - if( pPager->noReadlock ){
|
| - assert( pPager->readOnly );
|
| - pPager->state = PAGER_SHARED;
|
| - }else{
|
| + assert( pPager->noReadlock==0 || pPager->readOnly );
|
| +
|
| + if( pPager->noReadlock==0 ){
|
| rc = pager_wait_on_lock(pPager, SHARED_LOCK);
|
| if( rc!=SQLITE_OK ){
|
| - assert( pPager->state==PAGER_UNLOCK );
|
| - return pager_error(pPager, rc);
|
| + assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
|
| + goto failed;
|
| }
|
| }
|
| - assert( pPager->state>=SHARED_LOCK );
|
|
|
| /* If a journal file exists, and there is no RESERVED lock on the
|
| ** database file, then it either needs to be played back or deleted.
|
| */
|
| - if( !isErrorReset ){
|
| - assert( pPager->state <= PAGER_SHARED );
|
| - rc = hasHotJournal(pPager, &isHotJournal);
|
| - if( rc!=SQLITE_OK ){
|
| - goto failed;
|
| - }
|
| + if( pPager->eLock<=SHARED_LOCK ){
|
| + rc = hasHotJournal(pPager, &bHotJournal);
|
| }
|
| - if( isErrorReset || isHotJournal ){
|
| + if( rc!=SQLITE_OK ){
|
| + goto failed;
|
| + }
|
| + if( bHotJournal ){
|
| /* Get an EXCLUSIVE lock on the database file. At this point it is
|
| ** important that a RESERVED lock is not obtained on the way to the
|
| ** EXCLUSIVE lock. If it were, another process might open the
|
| @@ -3608,74 +4745,95 @@ int sqlite3PagerSharedLock(Pager *pPager){
|
| ** other process attempting to access the database file will get to
|
| ** this point in the code and fail to obtain its own EXCLUSIVE lock
|
| ** on the database file.
|
| + **
|
| + ** Unless the pager is in locking_mode=exclusive mode, the lock is
|
| + ** downgraded to SHARED_LOCK before this function returns.
|
| */
|
| - if( pPager->state<EXCLUSIVE_LOCK ){
|
| - rc = sqlite3OsLock(pPager->fd, EXCLUSIVE_LOCK);
|
| - if( rc!=SQLITE_OK ){
|
| - rc = pager_error(pPager, rc);
|
| - goto failed;
|
| - }
|
| - pPager->state = PAGER_EXCLUSIVE;
|
| + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
|
| + if( rc!=SQLITE_OK ){
|
| + goto failed;
|
| }
|
|
|
| - /* Open the journal for read/write access. This is because in
|
| - ** exclusive-access mode the file descriptor will be kept open and
|
| - ** possibly used for a transaction later on. On some systems, the
|
| - ** OsTruncate() call used in exclusive-access mode also requires
|
| - ** a read/write file handle.
|
| + /* If it is not already open and the file exists on disk, open the
|
| + ** journal for read/write access. Write access is required because
|
| + ** in exclusive-access mode the file descriptor will be kept open
|
| + ** and possibly used for a transaction later on. Also, write-access
|
| + ** is usually required to finalize the journal in journal_mode=persist
|
| + ** mode (and also for journal_mode=truncate on some systems).
|
| + **
|
| + ** If the journal does not exist, it usually means that some
|
| + ** other connection managed to get in and roll it back before
|
| + ** this connection obtained the exclusive lock above. Or, it
|
| + ** may mean that the pager was in the error-state when this
|
| + ** function was called and the journal file does not exist.
|
| */
|
| if( !isOpen(pPager->jfd) ){
|
| - int res;
|
| - rc = sqlite3OsAccess(pVfs,pPager->zJournal,SQLITE_ACCESS_EXISTS,&res);
|
| - if( rc==SQLITE_OK ){
|
| - if( res ){
|
| - int fout = 0;
|
| - int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
|
| - assert( !pPager->tempFile );
|
| - rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
|
| - assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
|
| - if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
|
| - rc = SQLITE_CANTOPEN;
|
| - sqlite3OsClose(pPager->jfd);
|
| - }
|
| - }else{
|
| - /* If the journal does not exist, it usually means that some
|
| - ** other connection managed to get in and roll it back before
|
| - ** this connection obtained the exclusive lock above. Or, it
|
| - ** may mean that the pager was in the error-state when this
|
| - ** function was called and the journal file does not exist. */
|
| - rc = pager_end_transaction(pPager, 0);
|
| + sqlite3_vfs * const pVfs = pPager->pVfs;
|
| + int bExists; /* True if journal file exists */
|
| + rc = sqlite3OsAccess(
|
| + pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
|
| + if( rc==SQLITE_OK && bExists ){
|
| + int fout = 0;
|
| + int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
|
| + assert( !pPager->tempFile );
|
| + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
|
| + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
|
| + if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
|
| + rc = SQLITE_CANTOPEN_BKPT;
|
| + sqlite3OsClose(pPager->jfd);
|
| }
|
| }
|
| }
|
| - if( rc!=SQLITE_OK ){
|
| - goto failed;
|
| - }
|
| -
|
| - /* TODO: Why are these cleared here? Is it necessary? */
|
| - pPager->journalStarted = 0;
|
| - pPager->journalOff = 0;
|
| - pPager->setMaster = 0;
|
| - pPager->journalHdr = 0;
|
|
|
| /* Playback and delete the journal. Drop the database write
|
| ** lock and reacquire the read lock. Purge the cache before
|
| ** playing back the hot-journal so that we don't end up with
|
| - ** an inconsistent cache.
|
| + ** an inconsistent cache. Sync the hot journal before playing
|
| + ** it back since the process that crashed and left the hot journal
|
| + ** probably did not sync it and we are required to always sync
|
| + ** the journal before playing it back.
|
| */
|
| if( isOpen(pPager->jfd) ){
|
| - rc = pager_playback(pPager, 1);
|
| - if( rc!=SQLITE_OK ){
|
| - rc = pager_error(pPager, rc);
|
| - goto failed;
|
| + assert( rc==SQLITE_OK );
|
| + rc = pagerSyncHotJournal(pPager);
|
| + if( rc==SQLITE_OK ){
|
| + rc = pager_playback(pPager, 1);
|
| + pPager->eState = PAGER_OPEN;
|
| }
|
| + }else if( !pPager->exclusiveMode ){
|
| + pagerUnlockDb(pPager, SHARED_LOCK);
|
| + }
|
| +
|
| + if( rc!=SQLITE_OK ){
|
| + /* This branch is taken if an error occurs while trying to open
|
| + ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
|
| + ** pager_unlock() routine will be called before returning to unlock
|
| + ** the file. If the unlock attempt fails, then Pager.eLock must be
|
| + ** set to UNKNOWN_LOCK (see the comment above the #define for
|
| + ** UNKNOWN_LOCK above for an explanation).
|
| + **
|
| + ** In order to get pager_unlock() to do this, set Pager.eState to
|
| + ** PAGER_ERROR now. This is not actually counted as a transition
|
| + ** to ERROR state in the state diagram at the top of this file,
|
| + ** since we know that the same call to pager_unlock() will very
|
| + ** shortly transition the pager object to the OPEN state. Calling
|
| + ** assert_pager_state() would fail now, as it should not be possible
|
| + ** to be in ERROR state when there are zero outstanding page
|
| + ** references.
|
| + */
|
| + pager_error(pPager, rc);
|
| + goto failed;
|
| }
|
| - assert( (pPager->state==PAGER_SHARED)
|
| - || (pPager->exclusiveMode && pPager->state>PAGER_SHARED)
|
| +
|
| + assert( pPager->eState==PAGER_OPEN );
|
| + assert( (pPager->eLock==SHARED_LOCK)
|
| + || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
|
| );
|
| }
|
|
|
| - if( pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0 ){
|
| + if( !pPager->tempFile
|
| + && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0)
|
| + ){
|
| /* The shared-lock has just been acquired on the database file
|
| ** and there are already pages in the cache (from a previous
|
| ** read or write transaction). Check to see if the database
|
| @@ -3692,16 +4850,13 @@ int sqlite3PagerSharedLock(Pager *pPager){
|
| ** detected. The chance of an undetected change is so small that
|
| ** it can be neglected.
|
| */
|
| + Pgno nPage = 0;
|
| char dbFileVers[sizeof(pPager->dbFileVers)];
|
| - sqlite3PagerPagecount(pPager, 0);
|
|
|
| - if( pPager->errCode ){
|
| - rc = pPager->errCode;
|
| - goto failed;
|
| - }
|
| + rc = pagerPagecount(pPager, &nPage);
|
| + if( rc ) goto failed;
|
|
|
| - assert( pPager->dbSizeValid );
|
| - if( pPager->dbSize>0 ){
|
| + if( nPage>0 ){
|
| IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
|
| rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
|
| if( rc!=SQLITE_OK ){
|
| @@ -3715,13 +4870,32 @@ int sqlite3PagerSharedLock(Pager *pPager){
|
| pager_reset(pPager);
|
| }
|
| }
|
| - assert( pPager->exclusiveMode || pPager->state==PAGER_SHARED );
|
| +
|
| + /* If there is a WAL file in the file-system, open this database in WAL
|
| + ** mode. Otherwise, the following function call is a no-op.
|
| + */
|
| + rc = pagerOpenWalIfPresent(pPager);
|
| +#ifndef SQLITE_OMIT_WAL
|
| + assert( pPager->pWal==0 || rc==SQLITE_OK );
|
| +#endif
|
| + }
|
| +
|
| + if( pagerUseWal(pPager) ){
|
| + assert( rc==SQLITE_OK );
|
| + rc = pagerBeginReadTransaction(pPager);
|
| + }
|
| +
|
| + if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
|
| + rc = pagerPagecount(pPager, &pPager->dbSize);
|
| }
|
|
|
| failed:
|
| if( rc!=SQLITE_OK ){
|
| - /* pager_unlock() is a no-op for exclusive mode and in-memory databases. */
|
| + assert( !MEMDB );
|
| pager_unlock(pPager);
|
| + assert( pPager->eState==PAGER_OPEN );
|
| + }else{
|
| + pPager->eState = PAGER_READER;
|
| }
|
| return rc;
|
| }
|
| @@ -3735,9 +4909,7 @@ int sqlite3PagerSharedLock(Pager *pPager){
|
| ** nothing to rollback, so this routine is a no-op.
|
| */
|
| static void pagerUnlockIfUnused(Pager *pPager){
|
| - if( (sqlite3PcacheRefCount(pPager->pPCache)==0)
|
| - && (!pPager->exclusiveMode || pPager->journalOff>0)
|
| - ){
|
| + if( (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
|
| pagerUnlockAndRollback(pPager);
|
| }
|
| }
|
| @@ -3770,7 +4942,7 @@ static void pagerUnlockIfUnused(Pager *pPager){
|
| ** a) When reading a free-list leaf page from the database, and
|
| **
|
| ** b) When a savepoint is being rolled back and we need to load
|
| -** a new page into the cache to populate with the data read
|
| +** a new page into the cache to be filled with the data read
|
| ** from the savepoint journal.
|
| **
|
| ** If noContent is true, then the data returned is zeroed instead of
|
| @@ -3820,8 +4992,8 @@ int sqlite3PagerAcquire2(
|
| int rc;
|
| PgHdr *pPg;
|
|
|
| + assert( pPager->eState>=PAGER_READER );
|
| assert( assert_pager_state(pPager) );
|
| - assert( pPager->state>PAGER_UNLOCK );
|
|
|
| if( pgno==0 ){
|
| return SQLITE_CORRUPT_BKPT;
|
| @@ -3829,7 +5001,7 @@ int sqlite3PagerAcquire2(
|
|
|
| /* If the pager is in the error state, return an error immediately.
|
| ** Otherwise, request the page from the PCache layer. */
|
| - if( pPager->errCode!=SQLITE_OK && pPager->errCode!=SQLITE_FULL ){
|
| + if( pPager->errCode!=SQLITE_OK ){
|
| rc = pPager->errCode;
|
| }else{
|
| rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
|
| @@ -3845,7 +5017,7 @@ int sqlite3PagerAcquire2(
|
| assert( (*ppPage)->pgno==pgno );
|
| assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
|
|
|
| - if( (*ppPage)->pPager ){
|
| + if( (*ppPage)->pPager && !noContent ){
|
| /* In this case the pcache already contains an initialized copy of
|
| ** the page. Return without further ado. */
|
| assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
|
| @@ -3855,7 +5027,6 @@ int sqlite3PagerAcquire2(
|
| }else{
|
| /* The pager cache has created a new page. Its content needs to
|
| ** be initialized. */
|
| - int nMax;
|
|
|
| PAGER_INCR(pPager->nMiss);
|
| pPg = *ppPage;
|
| @@ -3868,15 +5039,10 @@ int sqlite3PagerAcquire2(
|
| goto pager_acquire_err;
|
| }
|
|
|
| - rc = sqlite3PagerPagecount(pPager, &nMax);
|
| - if( rc!=SQLITE_OK ){
|
| - goto pager_acquire_err;
|
| - }
|
| -
|
| - if( nMax<(int)pgno || MEMDB || noContent ){
|
| + if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
|
| if( pgno>pPager->mxPgno ){
|
| - rc = SQLITE_FULL;
|
| - goto pager_acquire_err;
|
| + rc = SQLITE_FULL;
|
| + goto pager_acquire_err;
|
| }
|
| if( noContent ){
|
| /* Failure to set the bits in the InJournal bit-vectors is benign.
|
| @@ -3893,9 +5059,8 @@ int sqlite3PagerAcquire2(
|
| TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
|
| testcase( rc==SQLITE_NOMEM );
|
| sqlite3EndBenignMalloc();
|
| - }else{
|
| - memset(pPg->pData, 0, pPager->pageSize);
|
| }
|
| + memset(pPg->pData, 0, pPager->pageSize);
|
| IOTRACE(("ZERO %p %d\n", pPager, pgno));
|
| }else{
|
| assert( pPg->pPager==pPager );
|
| @@ -3912,9 +5077,7 @@ int sqlite3PagerAcquire2(
|
| }
|
| }
|
| }
|
| -#ifdef SQLITE_CHECK_PAGES
|
| - pPg->pageHash = pager_pagehash(pPg);
|
| -#endif
|
| + pager_set_pagehash(pPg);
|
| }
|
|
|
| return SQLITE_OK;
|
| @@ -3933,9 +5096,7 @@ pager_acquire_err:
|
| /*
|
| ** Acquire a page if it is already in the in-memory cache. Do
|
| ** not read the page from disk. Return a pointer to the page,
|
| -** or 0 if the page is not in cache. Also, return 0 if the
|
| -** pager is in PAGER_UNLOCK state when this function is called,
|
| -** or if the pager is in an error state other than SQLITE_FULL.
|
| +** or 0 if the page is not in cache.
|
| **
|
| ** See also sqlite3PagerGet(). The difference between this routine
|
| ** and sqlite3PagerGet() is that _get() will go to the disk and read
|
| @@ -3948,7 +5109,7 @@ DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
|
| assert( pPager!=0 );
|
| assert( pgno!=0 );
|
| assert( pPager->pPCache!=0 );
|
| - assert( pPager->state > PAGER_UNLOCK );
|
| + assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
|
| sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
|
| return pPg;
|
| }
|
| @@ -3970,27 +5131,6 @@ void sqlite3PagerUnref(DbPage *pPg){
|
| }
|
|
|
| /*
|
| -** If the main journal file has already been opened, ensure that the
|
| -** sub-journal file is open too. If the main journal is not open,
|
| -** this function is a no-op.
|
| -**
|
| -** SQLITE_OK is returned if everything goes according to plan.
|
| -** An SQLITE_IOERR_XXX error code is returned if a call to
|
| -** sqlite3OsOpen() fails.
|
| -*/
|
| -static int openSubJournal(Pager *pPager){
|
| - int rc = SQLITE_OK;
|
| - if( isOpen(pPager->jfd) && !isOpen(pPager->sjfd) ){
|
| - if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
|
| - sqlite3MemJournalOpen(pPager->sjfd);
|
| - }else{
|
| - rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
|
| - }
|
| - }
|
| - return rc;
|
| -}
|
| -
|
| -/*
|
| ** This function is called at the start of every write transaction.
|
| ** There must already be a RESERVED or EXCLUSIVE lock on the database
|
| ** file when this routine is called.
|
| @@ -4016,9 +5156,8 @@ static int pager_open_journal(Pager *pPager){
|
| int rc = SQLITE_OK; /* Return code */
|
| sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
|
|
|
| - assert( pPager->state>=PAGER_RESERVED );
|
| - assert( pPager->useJournal );
|
| - assert( pPager->journalMode!=PAGER_JOURNALMODE_OFF );
|
| + assert( pPager->eState==PAGER_WRITER_LOCKED );
|
| + assert( assert_pager_state(pPager) );
|
| assert( pPager->pInJournal==0 );
|
|
|
| /* If already in the error state, this function is a no-op. But on
|
| @@ -4026,62 +5165,56 @@ static int pager_open_journal(Pager *pPager){
|
| ** an error state. */
|
| if( NEVER(pPager->errCode) ) return pPager->errCode;
|
|
|
| - /* TODO: Is it really possible to get here with dbSizeValid==0? If not,
|
| - ** the call to PagerPagecount() can be removed.
|
| - */
|
| - testcase( pPager->dbSizeValid==0 );
|
| - sqlite3PagerPagecount(pPager, 0);
|
| -
|
| - pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
|
| - if( pPager->pInJournal==0 ){
|
| - return SQLITE_NOMEM;
|
| - }
|
| -
|
| - /* Open the journal file if it is not already open. */
|
| - if( !isOpen(pPager->jfd) ){
|
| - if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
|
| - sqlite3MemJournalOpen(pPager->jfd);
|
| - }else{
|
| - const int flags = /* VFS flags to open journal file */
|
| - SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
|
| - (pPager->tempFile ?
|
| - (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
|
| - (SQLITE_OPEN_MAIN_JOURNAL)
|
| + if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
|
| + pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
|
| + if( pPager->pInJournal==0 ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| +
|
| + /* Open the journal file if it is not already open. */
|
| + if( !isOpen(pPager->jfd) ){
|
| + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
|
| + sqlite3MemJournalOpen(pPager->jfd);
|
| + }else{
|
| + const int flags = /* VFS flags to open journal file */
|
| + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
|
| + (pPager->tempFile ?
|
| + (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
|
| + (SQLITE_OPEN_MAIN_JOURNAL)
|
| + );
|
| + #ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| + rc = sqlite3JournalOpen(
|
| + pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
|
| );
|
| -#ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| - rc = sqlite3JournalOpen(
|
| - pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
|
| - );
|
| -#else
|
| - rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
|
| -#endif
|
| + #else
|
| + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
|
| + #endif
|
| + }
|
| + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
|
| + }
|
| +
|
| +
|
| + /* Write the first journal header to the journal file and open
|
| + ** the sub-journal if necessary.
|
| + */
|
| + if( rc==SQLITE_OK ){
|
| + /* TODO: Check if all of these are really required. */
|
| + pPager->nRec = 0;
|
| + pPager->journalOff = 0;
|
| + pPager->setMaster = 0;
|
| + pPager->journalHdr = 0;
|
| + rc = writeJournalHdr(pPager);
|
| }
|
| - assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
|
| - }
|
| -
|
| -
|
| - /* Write the first journal header to the journal file and open
|
| - ** the sub-journal if necessary.
|
| - */
|
| - if( rc==SQLITE_OK ){
|
| - /* TODO: Check if all of these are really required. */
|
| - pPager->dbOrigSize = pPager->dbSize;
|
| - pPager->journalStarted = 0;
|
| - pPager->needSync = 0;
|
| - pPager->nRec = 0;
|
| - pPager->journalOff = 0;
|
| - pPager->setMaster = 0;
|
| - pPager->journalHdr = 0;
|
| - rc = writeJournalHdr(pPager);
|
| - }
|
| - if( rc==SQLITE_OK && pPager->nSavepoint ){
|
| - rc = openSubJournal(pPager);
|
| }
|
|
|
| if( rc!=SQLITE_OK ){
|
| sqlite3BitvecDestroy(pPager->pInJournal);
|
| pPager->pInJournal = 0;
|
| + }else{
|
| + assert( pPager->eState==PAGER_WRITER_LOCKED );
|
| + pPager->eState = PAGER_WRITER_CACHEMOD;
|
| }
|
| +
|
| return rc;
|
| }
|
|
|
| @@ -4094,14 +5227,6 @@ static int pager_open_journal(Pager *pPager){
|
| ** an EXCLUSIVE lock. If such a lock is already held, no locking
|
| ** functions need be called.
|
| **
|
| -** If this is not a temporary or in-memory file and, the journal file is
|
| -** opened if it has not been already. For a temporary file, the opening
|
| -** of the journal file is deferred until there is an actual need to
|
| -** write to the journal. TODO: Why handle temporary files differently?
|
| -**
|
| -** If the journal file is opened (or if it is already open), then a
|
| -** journal-header is written to the start of it.
|
| -**
|
| ** If the subjInMemory argument is non-zero, then any sub-journal opened
|
| ** within this transaction will be opened as an in-memory file. This
|
| ** has no effect if the sub-journal is already opened (as it may be when
|
| @@ -4112,55 +5237,67 @@ static int pager_open_journal(Pager *pPager){
|
| */
|
| int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
|
| int rc = SQLITE_OK;
|
| - assert( pPager->state!=PAGER_UNLOCK );
|
| +
|
| + if( pPager->errCode ) return pPager->errCode;
|
| + assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
|
| pPager->subjInMemory = (u8)subjInMemory;
|
| - if( pPager->state==PAGER_SHARED ){
|
| +
|
| + if( ALWAYS(pPager->eState==PAGER_READER) ){
|
| assert( pPager->pInJournal==0 );
|
| - assert( !MEMDB && !pPager->tempFile );
|
|
|
| - /* Obtain a RESERVED lock on the database file. If the exFlag parameter
|
| - ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
|
| - ** busy-handler callback can be used when upgrading to the EXCLUSIVE
|
| - ** lock, but not when obtaining the RESERVED lock.
|
| - */
|
| - rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK);
|
| - if( rc==SQLITE_OK ){
|
| - pPager->state = PAGER_RESERVED;
|
| - if( exFlag ){
|
| + if( pagerUseWal(pPager) ){
|
| + /* If the pager is configured to use locking_mode=exclusive, and an
|
| + ** exclusive lock on the database is not already held, obtain it now.
|
| + */
|
| + if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
|
| + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| + sqlite3WalExclusiveMode(pPager->pWal, 1);
|
| + }
|
| +
|
| + /* Grab the write lock on the log file. If successful, upgrade to
|
| + ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
|
| + ** The busy-handler is not invoked if another connection already
|
| + ** holds the write-lock. If possible, the upper layer will call it.
|
| + */
|
| + rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
|
| + }else{
|
| + /* Obtain a RESERVED lock on the database file. If the exFlag parameter
|
| + ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
|
| + ** busy-handler callback can be used when upgrading to the EXCLUSIVE
|
| + ** lock, but not when obtaining the RESERVED lock.
|
| + */
|
| + rc = pagerLockDb(pPager, RESERVED_LOCK);
|
| + if( rc==SQLITE_OK && exFlag ){
|
| rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
|
| }
|
| }
|
|
|
| - /* If the required locks were successfully obtained, open the journal
|
| - ** file and write the first journal-header to it.
|
| - */
|
| - if( rc==SQLITE_OK && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
|
| - rc = pager_open_journal(pPager);
|
| + if( rc==SQLITE_OK ){
|
| + /* Change to WRITER_LOCKED state.
|
| + **
|
| + ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
|
| + ** when it has an open transaction, but never to DBMOD or FINISHED.
|
| + ** This is because in those states the code to roll back savepoint
|
| + ** transactions may copy data from the sub-journal into the database
|
| + ** file as well as into the page cache. Which would be incorrect in
|
| + ** WAL mode.
|
| + */
|
| + pPager->eState = PAGER_WRITER_LOCKED;
|
| + pPager->dbHintSize = pPager->dbSize;
|
| + pPager->dbFileSize = pPager->dbSize;
|
| + pPager->dbOrigSize = pPager->dbSize;
|
| + pPager->journalOff = 0;
|
| }
|
| - }else if( isOpen(pPager->jfd) && pPager->journalOff==0 ){
|
| - /* This happens when the pager was in exclusive-access mode the last
|
| - ** time a (read or write) transaction was successfully concluded
|
| - ** by this connection. Instead of deleting the journal file it was
|
| - ** kept open and either was truncated to 0 bytes or its header was
|
| - ** overwritten with zeros.
|
| - */
|
| - assert( pPager->nRec==0 );
|
| - assert( pPager->dbOrigSize==0 );
|
| - assert( pPager->pInJournal==0 );
|
| - rc = pager_open_journal(pPager);
|
| +
|
| + assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
|
| + assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
|
| + assert( assert_pager_state(pPager) );
|
| }
|
|
|
| PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
|
| - assert( !isOpen(pPager->jfd) || pPager->journalOff>0 || rc!=SQLITE_OK );
|
| - if( rc!=SQLITE_OK ){
|
| - assert( !pPager->dbModified );
|
| - /* Ignore any IO error that occurs within pager_end_transaction(). The
|
| - ** purpose of this call is to reset the internal state of the pager
|
| - ** sub-system. It doesn't matter if the journal-file is not properly
|
| - ** finalized at this point (since it is not a valid journal file anyway).
|
| - */
|
| - pager_end_transaction(pPager, 0);
|
| - }
|
| return rc;
|
| }
|
|
|
| @@ -4176,102 +5313,94 @@ static int pager_write(PgHdr *pPg){
|
| Pager *pPager = pPg->pPager;
|
| int rc = SQLITE_OK;
|
|
|
| - /* This routine is not called unless a transaction has already been
|
| - ** started.
|
| + /* This routine is not called unless a write-transaction has already
|
| + ** been started. The journal file may or may not be open at this point.
|
| + ** It is never called in the ERROR state.
|
| */
|
| - assert( pPager->state>=PAGER_RESERVED );
|
| + assert( pPager->eState==PAGER_WRITER_LOCKED
|
| + || pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
|
|
| - /* If an error has been previously detected, we should not be
|
| - ** calling this routine. Repeat the error for robustness.
|
| - */
|
| + /* If an error has been previously detected, report the same error
|
| + ** again. This should not happen, but the check provides robustness. */
|
| if( NEVER(pPager->errCode) ) return pPager->errCode;
|
|
|
| /* Higher-level routines never call this function if database is not
|
| ** writable. But check anyway, just for robustness. */
|
| if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
|
|
|
| - assert( !pPager->setMaster );
|
| -
|
| CHECK_PAGE(pPg);
|
|
|
| + /* The journal file needs to be opened. Higher level routines have already
|
| + ** obtained the necessary locks to begin the write-transaction, but the
|
| + ** rollback journal might not yet be open. Open it now if this is the case.
|
| + **
|
| + ** This is done before calling sqlite3PcacheMakeDirty() on the page.
|
| + ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
|
| + ** an error might occur and the pager would end up in WRITER_LOCKED state
|
| + ** with pages marked as dirty in the cache.
|
| + */
|
| + if( pPager->eState==PAGER_WRITER_LOCKED ){
|
| + rc = pager_open_journal(pPager);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| + }
|
| + assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
|
| + assert( assert_pager_state(pPager) );
|
| +
|
| /* Mark the page as dirty. If the page has already been written
|
| ** to the journal then we can return right away.
|
| */
|
| sqlite3PcacheMakeDirty(pPg);
|
| if( pageInJournal(pPg) && !subjRequiresPage(pPg) ){
|
| - pPager->dbModified = 1;
|
| + assert( !pagerUseWal(pPager) );
|
| }else{
|
| -
|
| - /* If we get this far, it means that the page needs to be
|
| - ** written to the transaction journal or the ckeckpoint journal
|
| - ** or both.
|
| - **
|
| - ** Higher level routines should have already started a transaction,
|
| - ** which means they have acquired the necessary locks and opened
|
| - ** a rollback journal. Double-check to makes sure this is the case.
|
| - */
|
| - rc = sqlite3PagerBegin(pPager, 0, pPager->subjInMemory);
|
| - if( NEVER(rc!=SQLITE_OK) ){
|
| - return rc;
|
| - }
|
| - if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
|
| - assert( pPager->useJournal );
|
| - rc = pager_open_journal(pPager);
|
| - if( rc!=SQLITE_OK ) return rc;
|
| - }
|
| - pPager->dbModified = 1;
|
|
|
| /* The transaction journal now exists and we have a RESERVED or an
|
| ** EXCLUSIVE lock on the main database file. Write the current page to
|
| ** the transaction journal if it is not there already.
|
| */
|
| - if( !pageInJournal(pPg) && isOpen(pPager->jfd) ){
|
| - if( pPg->pgno<=pPager->dbOrigSize ){
|
| + if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
|
| + assert( pagerUseWal(pPager)==0 );
|
| + if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
|
| u32 cksum;
|
| char *pData2;
|
| + i64 iOff = pPager->journalOff;
|
|
|
| /* We should never write to the journal file the page that
|
| ** contains the database locks. The following assert verifies
|
| ** that we do not. */
|
| assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
|
| +
|
| + assert( pPager->journalHdr<=pPager->journalOff );
|
| CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
|
| cksum = pager_cksum(pPager, (u8*)pData2);
|
| - rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno);
|
| - if( rc==SQLITE_OK ){
|
| - rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize,
|
| - pPager->journalOff + 4);
|
| - pPager->journalOff += pPager->pageSize+4;
|
| - }
|
| - if( rc==SQLITE_OK ){
|
| - rc = write32bits(pPager->jfd, pPager->journalOff, cksum);
|
| - pPager->journalOff += 4;
|
| - }
|
| - IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
|
| - pPager->journalOff, pPager->pageSize));
|
| - PAGER_INCR(sqlite3_pager_writej_count);
|
| - PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
|
| - PAGERID(pPager), pPg->pgno,
|
| - ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
|
|
|
| - /* Even if an IO or diskfull error occurred while journalling the
|
| + /* Even if an IO or diskfull error occurs while journalling the
|
| ** page in the block above, set the need-sync flag for the page.
|
| ** Otherwise, when the transaction is rolled back, the logic in
|
| ** playback_one_page() will think that the page needs to be restored
|
| ** in the database file. And if an IO error occurs while doing so,
|
| ** then corruption may follow.
|
| */
|
| - if( !pPager->noSync ){
|
| - pPg->flags |= PGHDR_NEED_SYNC;
|
| - pPager->needSync = 1;
|
| - }
|
| + pPg->flags |= PGHDR_NEED_SYNC;
|
|
|
| - /* An error has occurred writing to the journal file. The
|
| - ** transaction will be rolled back by the layer above.
|
| - */
|
| - if( rc!=SQLITE_OK ){
|
| - return rc;
|
| - }
|
| + rc = write32bits(pPager->jfd, iOff, pPg->pgno);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| + rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| + rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| +
|
| + IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
|
| + pPager->journalOff, pPager->pageSize));
|
| + PAGER_INCR(sqlite3_pager_writej_count);
|
| + PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
|
| + PAGERID(pPager), pPg->pgno,
|
| + ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
|
|
|
| + pPager->journalOff += 8 + pPager->pageSize;
|
| pPager->nRec++;
|
| assert( pPager->pInJournal!=0 );
|
| rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
|
| @@ -4283,9 +5412,8 @@ static int pager_write(PgHdr *pPg){
|
| return rc;
|
| }
|
| }else{
|
| - if( !pPager->journalStarted && !pPager->noSync ){
|
| + if( pPager->eState!=PAGER_WRITER_DBMOD ){
|
| pPg->flags |= PGHDR_NEED_SYNC;
|
| - pPager->needSync = 1;
|
| }
|
| PAGERTRACE(("APPEND %d page %d needSync=%d\n",
|
| PAGERID(pPager), pPg->pgno,
|
| @@ -4305,7 +5433,6 @@ static int pager_write(PgHdr *pPg){
|
|
|
| /* Update the database size and return.
|
| */
|
| - assert( pPager->state>=PAGER_SHARED );
|
| if( pPager->dbSize<pPg->pgno ){
|
| pPager->dbSize = pPg->pgno;
|
| }
|
| @@ -4333,19 +5460,24 @@ int sqlite3PagerWrite(DbPage *pDbPage){
|
| Pager *pPager = pPg->pPager;
|
| Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
|
|
|
| + assert( pPager->eState>=PAGER_WRITER_LOCKED );
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| + assert( assert_pager_state(pPager) );
|
| +
|
| if( nPagePerSector>1 ){
|
| Pgno nPageCount; /* Total number of pages in database file */
|
| Pgno pg1; /* First page of the sector pPg is located on. */
|
| - int nPage; /* Number of pages starting at pg1 to journal */
|
| + int nPage = 0; /* Number of pages starting at pg1 to journal */
|
| int ii; /* Loop counter */
|
| int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
|
|
|
| - /* Set the doNotSync flag to 1. This is because we cannot allow a journal
|
| - ** header to be written between the pages journaled by this function.
|
| + /* Set the doNotSyncSpill flag to 1. This is because we cannot allow
|
| + ** a journal header to be written between the pages journaled by
|
| + ** this function.
|
| */
|
| assert( !MEMDB );
|
| - assert( pPager->doNotSync==0 );
|
| - pPager->doNotSync = 1;
|
| + assert( pPager->doNotSyncSpill==0 );
|
| + pPager->doNotSyncSpill++;
|
|
|
| /* This trick assumes that both the page-size and sector-size are
|
| ** an integer power of 2. It sets variable pg1 to the identifier
|
| @@ -4353,7 +5485,7 @@ int sqlite3PagerWrite(DbPage *pDbPage){
|
| */
|
| pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
|
|
|
| - sqlite3PagerPagecount(pPager, (int *)&nPageCount);
|
| + nPageCount = pPager->dbSize;
|
| if( pPg->pgno>nPageCount ){
|
| nPage = (pPg->pgno - pg1)+1;
|
| }else if( (pg1+nPagePerSector-1)>nPageCount ){
|
| @@ -4375,7 +5507,6 @@ int sqlite3PagerWrite(DbPage *pDbPage){
|
| rc = pager_write(pPage);
|
| if( pPage->flags&PGHDR_NEED_SYNC ){
|
| needSync = 1;
|
| - assert(pPager->needSync);
|
| }
|
| sqlite3PagerUnref(pPage);
|
| }
|
| @@ -4395,7 +5526,7 @@ int sqlite3PagerWrite(DbPage *pDbPage){
|
| ** before any of them can be written out to the database file.
|
| */
|
| if( rc==SQLITE_OK && needSync ){
|
| - assert( !MEMDB && pPager->noSync==0 );
|
| + assert( !MEMDB );
|
| for(ii=0; ii<nPage; ii++){
|
| PgHdr *pPage = pager_lookup(pPager, pg1+ii);
|
| if( pPage ){
|
| @@ -4403,11 +5534,10 @@ int sqlite3PagerWrite(DbPage *pDbPage){
|
| sqlite3PagerUnref(pPage);
|
| }
|
| }
|
| - assert(pPager->needSync);
|
| }
|
|
|
| - assert( pPager->doNotSync==1 );
|
| - pPager->doNotSync = 0;
|
| + assert( pPager->doNotSyncSpill==1 );
|
| + pPager->doNotSyncSpill--;
|
| }else{
|
| rc = pager_write(pDbPage);
|
| }
|
| @@ -4445,16 +5575,20 @@ void sqlite3PagerDontWrite(PgHdr *pPg){
|
| PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
|
| IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
|
| pPg->flags |= PGHDR_DONT_WRITE;
|
| -#ifdef SQLITE_CHECK_PAGES
|
| - pPg->pageHash = pager_pagehash(pPg);
|
| -#endif
|
| + pager_set_pagehash(pPg);
|
| }
|
| }
|
|
|
| /*
|
| ** This routine is called to increment the value of the database file
|
| ** change-counter, stored as a 4-byte big-endian integer starting at
|
| -** byte offset 24 of the pager file.
|
| +** byte offset 24 of the pager file. The secondary change counter at
|
| +** 92 is also updated, as is the SQLite version number at offset 96.
|
| +**
|
| +** But this only happens if the pPager->changeCountDone flag is false.
|
| +** To avoid excess churning of page 1, the update only happens once.
|
| +** See also the pager_write_changecounter() routine that does an
|
| +** unconditional update of the change counters.
|
| **
|
| ** If the isDirectMode flag is zero, then this is done by calling
|
| ** sqlite3PagerWrite() on page 1, then modifying the contents of the
|
| @@ -4470,6 +5604,11 @@ void sqlite3PagerDontWrite(PgHdr *pPg){
|
| static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
|
| int rc = SQLITE_OK;
|
|
|
| + assert( pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
| +
|
| /* Declare and initialize constant integer 'isDirect'. If the
|
| ** atomic-write optimization is enabled in this build, then isDirect
|
| ** is initialized to the value passed as the isDirectMode parameter
|
| @@ -4488,10 +5627,8 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
|
| # define DIRECT_MODE isDirectMode
|
| #endif
|
|
|
| - assert( pPager->state>=PAGER_RESERVED );
|
| - if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){
|
| + if( !pPager->changeCountDone && pPager->dbSize>0 ){
|
| PgHdr *pPgHdr; /* Reference to page 1 */
|
| - u32 change_counter; /* Initial value of change-counter field */
|
|
|
| assert( !pPager->tempFile && isOpen(pPager->fd) );
|
|
|
| @@ -4509,16 +5646,17 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
|
| }
|
|
|
| if( rc==SQLITE_OK ){
|
| - /* Increment the value just read and write it back to byte 24. */
|
| - change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers);
|
| - change_counter++;
|
| - put32bits(((char*)pPgHdr->pData)+24, change_counter);
|
| + /* Actually do the update of the change counter */
|
| + pager_write_changecounter(pPgHdr);
|
|
|
| /* If running in direct mode, write the contents of page 1 to the file. */
|
| if( DIRECT_MODE ){
|
| - const void *zBuf = pPgHdr->pData;
|
| + const void *zBuf;
|
| assert( pPager->dbFileSize>0 );
|
| - rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
|
| + CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
|
| + }
|
| if( rc==SQLITE_OK ){
|
| pPager->changeCountDone = 1;
|
| }
|
| @@ -4534,19 +5672,44 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
|
| }
|
|
|
| /*
|
| -** Sync the pager file to disk. This is a no-op for in-memory files
|
| +** Sync the database file to disk. This is a no-op for in-memory databases
|
| ** or pages with the Pager.noSync flag set.
|
| **
|
| -** If successful, or called on a pager for which it is a no-op, this
|
| +** If successful, or if called on a pager for which it is a no-op, this
|
| ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
|
| */
|
| int sqlite3PagerSync(Pager *pPager){
|
| - int rc; /* Return code */
|
| - assert( !MEMDB );
|
| - if( pPager->noSync ){
|
| - rc = SQLITE_OK;
|
| - }else{
|
| - rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
|
| + int rc = SQLITE_OK;
|
| + if( !pPager->noSync ){
|
| + assert( !MEMDB );
|
| + rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
|
| + }else if( isOpen(pPager->fd) ){
|
| + assert( !MEMDB );
|
| + sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC_OMITTED, (void *)&rc);
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function may only be called while a write-transaction is active in
|
| +** rollback. If the connection is in WAL mode, this call is a no-op.
|
| +** Otherwise, if the connection does not already have an EXCLUSIVE lock on
|
| +** the database file, an attempt is made to obtain one.
|
| +**
|
| +** If the EXCLUSIVE lock is already held or the attempt to obtain it is
|
| +** successful, or the connection is in WAL mode, SQLITE_OK is returned.
|
| +** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
|
| +** returned.
|
| +*/
|
| +int sqlite3PagerExclusiveLock(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| + assert( pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + || pPager->eState==PAGER_WRITER_LOCKED
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
| + if( 0==pagerUseWal(pPager) ){
|
| + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
|
| }
|
| return rc;
|
| }
|
| @@ -4584,151 +5747,184 @@ int sqlite3PagerCommitPhaseOne(
|
| ){
|
| int rc = SQLITE_OK; /* Return code */
|
|
|
| - /* The dbOrigSize is never set if journal_mode=OFF */
|
| - assert( pPager->journalMode!=PAGER_JOURNALMODE_OFF || pPager->dbOrigSize==0 );
|
| + assert( pPager->eState==PAGER_WRITER_LOCKED
|
| + || pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + || pPager->eState==PAGER_ERROR
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
|
|
| - /* If a prior error occurred, this routine should not be called. ROLLBACK
|
| - ** is the appropriate response to an error, not COMMIT. Guard against
|
| - ** coding errors by repeating the prior error. */
|
| + /* If a prior error occurred, report that error again. */
|
| if( NEVER(pPager->errCode) ) return pPager->errCode;
|
|
|
| PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
|
| pPager->zFilename, zMaster, pPager->dbSize));
|
|
|
| - if( MEMDB && pPager->dbModified ){
|
| + /* If no database changes have been made, return early. */
|
| + if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
|
| +
|
| + if( MEMDB ){
|
| /* If this is an in-memory db, or no pages have been written to, or this
|
| ** function has already been called, it is mostly a no-op. However, any
|
| ** backup in progress needs to be restarted.
|
| */
|
| sqlite3BackupRestart(pPager->pBackup);
|
| - }else if( pPager->state!=PAGER_SYNCED && pPager->dbModified ){
|
| -
|
| - /* The following block updates the change-counter. Exactly how it
|
| - ** does this depends on whether or not the atomic-update optimization
|
| - ** was enabled at compile time, and if this transaction meets the
|
| - ** runtime criteria to use the operation:
|
| - **
|
| - ** * The file-system supports the atomic-write property for
|
| - ** blocks of size page-size, and
|
| - ** * This commit is not part of a multi-file transaction, and
|
| - ** * Exactly one page has been modified and store in the journal file.
|
| - **
|
| - ** If the optimization was not enabled at compile time, then the
|
| - ** pager_incr_changecounter() function is called to update the change
|
| - ** counter in 'indirect-mode'. If the optimization is compiled in but
|
| - ** is not applicable to this transaction, call sqlite3JournalCreate()
|
| - ** to make sure the journal file has actually been created, then call
|
| - ** pager_incr_changecounter() to update the change-counter in indirect
|
| - ** mode.
|
| - **
|
| - ** Otherwise, if the optimization is both enabled and applicable,
|
| - ** then call pager_incr_changecounter() to update the change-counter
|
| - ** in 'direct' mode. In this case the journal file will never be
|
| - ** created for this transaction.
|
| - */
|
| -#ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| - PgHdr *pPg;
|
| - assert( isOpen(pPager->jfd) || pPager->journalMode==PAGER_JOURNALMODE_OFF );
|
| - if( !zMaster && isOpen(pPager->jfd)
|
| - && pPager->journalOff==jrnlBufferSize(pPager)
|
| - && pPager->dbSize>=pPager->dbFileSize
|
| - && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
|
| - ){
|
| - /* Update the db file change counter via the direct-write method. The
|
| - ** following call will modify the in-memory representation of page 1
|
| - ** to include the updated change counter and then write page 1
|
| - ** directly to the database file. Because of the atomic-write
|
| - ** property of the host file-system, this is safe.
|
| - */
|
| - rc = pager_incr_changecounter(pPager, 1);
|
| - }else{
|
| - rc = sqlite3JournalCreate(pPager->jfd);
|
| + }else{
|
| + if( pagerUseWal(pPager) ){
|
| + PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
|
| + PgHdr *pPageOne = 0;
|
| + if( pList==0 ){
|
| + /* Must have at least one page for the WAL commit flag.
|
| + ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
|
| + rc = sqlite3PagerGet(pPager, 1, &pPageOne);
|
| + pList = pPageOne;
|
| + pList->pDirty = 0;
|
| + }
|
| + assert( pList!=0 || rc!=SQLITE_OK );
|
| + if( pList ){
|
| + rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1,
|
| + (pPager->fullSync ? pPager->syncFlags : 0)
|
| + );
|
| + }
|
| + sqlite3PagerUnref(pPageOne);
|
| if( rc==SQLITE_OK ){
|
| - rc = pager_incr_changecounter(pPager, 0);
|
| + sqlite3PcacheCleanAll(pPager->pPCache);
|
| }
|
| - }
|
| -#else
|
| - rc = pager_incr_changecounter(pPager, 0);
|
| -#endif
|
| - if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| -
|
| - /* If this transaction has made the database smaller, then all pages
|
| - ** being discarded by the truncation must be written to the journal
|
| - ** file. This can only happen in auto-vacuum mode.
|
| - **
|
| - ** Before reading the pages with page numbers larger than the
|
| - ** current value of Pager.dbSize, set dbSize back to the value
|
| - ** that it took at the start of the transaction. Otherwise, the
|
| - ** calls to sqlite3PagerGet() return zeroed pages instead of
|
| - ** reading data from the database file.
|
| - **
|
| - ** When journal_mode==OFF the dbOrigSize is always zero, so this
|
| - ** block never runs if journal_mode=OFF.
|
| - */
|
| -#ifndef SQLITE_OMIT_AUTOVACUUM
|
| - if( pPager->dbSize<pPager->dbOrigSize
|
| - && ALWAYS(pPager->journalMode!=PAGER_JOURNALMODE_OFF)
|
| - ){
|
| - Pgno i; /* Iterator variable */
|
| - const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
|
| - const Pgno dbSize = pPager->dbSize; /* Database image size */
|
| - pPager->dbSize = pPager->dbOrigSize;
|
| - for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
|
| - if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
|
| - PgHdr *pPage; /* Page to journal */
|
| - rc = sqlite3PagerGet(pPager, i, &pPage);
|
| - if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| - rc = sqlite3PagerWrite(pPage);
|
| - sqlite3PagerUnref(pPage);
|
| - if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| + }else{
|
| + /* The following block updates the change-counter. Exactly how it
|
| + ** does this depends on whether or not the atomic-update optimization
|
| + ** was enabled at compile time, and if this transaction meets the
|
| + ** runtime criteria to use the operation:
|
| + **
|
| + ** * The file-system supports the atomic-write property for
|
| + ** blocks of size page-size, and
|
| + ** * This commit is not part of a multi-file transaction, and
|
| + ** * Exactly one page has been modified and store in the journal file.
|
| + **
|
| + ** If the optimization was not enabled at compile time, then the
|
| + ** pager_incr_changecounter() function is called to update the change
|
| + ** counter in 'indirect-mode'. If the optimization is compiled in but
|
| + ** is not applicable to this transaction, call sqlite3JournalCreate()
|
| + ** to make sure the journal file has actually been created, then call
|
| + ** pager_incr_changecounter() to update the change-counter in indirect
|
| + ** mode.
|
| + **
|
| + ** Otherwise, if the optimization is both enabled and applicable,
|
| + ** then call pager_incr_changecounter() to update the change-counter
|
| + ** in 'direct' mode. In this case the journal file will never be
|
| + ** created for this transaction.
|
| + */
|
| + #ifdef SQLITE_ENABLE_ATOMIC_WRITE
|
| + PgHdr *pPg;
|
| + assert( isOpen(pPager->jfd)
|
| + || pPager->journalMode==PAGER_JOURNALMODE_OFF
|
| + || pPager->journalMode==PAGER_JOURNALMODE_WAL
|
| + );
|
| + if( !zMaster && isOpen(pPager->jfd)
|
| + && pPager->journalOff==jrnlBufferSize(pPager)
|
| + && pPager->dbSize>=pPager->dbOrigSize
|
| + && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
|
| + ){
|
| + /* Update the db file change counter via the direct-write method. The
|
| + ** following call will modify the in-memory representation of page 1
|
| + ** to include the updated change counter and then write page 1
|
| + ** directly to the database file. Because of the atomic-write
|
| + ** property of the host file-system, this is safe.
|
| + */
|
| + rc = pager_incr_changecounter(pPager, 1);
|
| + }else{
|
| + rc = sqlite3JournalCreate(pPager->jfd);
|
| + if( rc==SQLITE_OK ){
|
| + rc = pager_incr_changecounter(pPager, 0);
|
| }
|
| + }
|
| + #else
|
| + rc = pager_incr_changecounter(pPager, 0);
|
| + #endif
|
| + if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| +
|
| + /* If this transaction has made the database smaller, then all pages
|
| + ** being discarded by the truncation must be written to the journal
|
| + ** file. This can only happen in auto-vacuum mode.
|
| + **
|
| + ** Before reading the pages with page numbers larger than the
|
| + ** current value of Pager.dbSize, set dbSize back to the value
|
| + ** that it took at the start of the transaction. Otherwise, the
|
| + ** calls to sqlite3PagerGet() return zeroed pages instead of
|
| + ** reading data from the database file.
|
| + */
|
| + #ifndef SQLITE_OMIT_AUTOVACUUM
|
| + if( pPager->dbSize<pPager->dbOrigSize
|
| + && pPager->journalMode!=PAGER_JOURNALMODE_OFF
|
| + ){
|
| + Pgno i; /* Iterator variable */
|
| + const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
|
| + const Pgno dbSize = pPager->dbSize; /* Database image size */
|
| + pPager->dbSize = pPager->dbOrigSize;
|
| + for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
|
| + if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
|
| + PgHdr *pPage; /* Page to journal */
|
| + rc = sqlite3PagerGet(pPager, i, &pPage);
|
| + if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| + rc = sqlite3PagerWrite(pPage);
|
| + sqlite3PagerUnref(pPage);
|
| + if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| + }
|
| + }
|
| + pPager->dbSize = dbSize;
|
| }
|
| - pPager->dbSize = dbSize;
|
| - }
|
| -#endif
|
| -
|
| - /* Write the master journal name into the journal file. If a master
|
| - ** journal file name has already been written to the journal file,
|
| - ** or if zMaster is NULL (no master journal), then this call is a no-op.
|
| - */
|
| - rc = writeMasterJournal(pPager, zMaster);
|
| - if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| -
|
| - /* Sync the journal file. If the atomic-update optimization is being
|
| - ** used, this call will not create the journal file or perform any
|
| - ** real IO.
|
| - */
|
| - rc = syncJournal(pPager);
|
| - if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| -
|
| - /* Write all dirty pages to the database file. */
|
| - rc = pager_write_pagelist(sqlite3PcacheDirtyList(pPager->pPCache));
|
| - if( rc!=SQLITE_OK ){
|
| - assert( rc!=SQLITE_IOERR_BLOCKED );
|
| - goto commit_phase_one_exit;
|
| - }
|
| - sqlite3PcacheCleanAll(pPager->pPCache);
|
| -
|
| - /* If the file on disk is not the same size as the database image,
|
| - ** then use pager_truncate to grow or shrink the file here.
|
| - */
|
| - if( pPager->dbSize!=pPager->dbFileSize ){
|
| - Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
|
| - assert( pPager->state>=PAGER_EXCLUSIVE );
|
| - rc = pager_truncate(pPager, nNew);
|
| + #endif
|
| +
|
| + /* Write the master journal name into the journal file. If a master
|
| + ** journal file name has already been written to the journal file,
|
| + ** or if zMaster is NULL (no master journal), then this call is a no-op.
|
| + */
|
| + rc = writeMasterJournal(pPager, zMaster);
|
| if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| +
|
| + /* Sync the journal file and write all dirty pages to the database.
|
| + ** If the atomic-update optimization is being used, this sync will not
|
| + ** create the journal file or perform any real IO.
|
| + **
|
| + ** Because the change-counter page was just modified, unless the
|
| + ** atomic-update optimization is used it is almost certain that the
|
| + ** journal requires a sync here. However, in locking_mode=exclusive
|
| + ** on a system under memory pressure it is just possible that this is
|
| + ** not the case. In this case it is likely enough that the redundant
|
| + ** xSync() call will be changed to a no-op by the OS anyhow.
|
| + */
|
| + rc = syncJournal(pPager, 0);
|
| + if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| +
|
| + rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
|
| + if( rc!=SQLITE_OK ){
|
| + assert( rc!=SQLITE_IOERR_BLOCKED );
|
| + goto commit_phase_one_exit;
|
| + }
|
| + sqlite3PcacheCleanAll(pPager->pPCache);
|
| +
|
| + /* If the file on disk is not the same size as the database image,
|
| + ** then use pager_truncate to grow or shrink the file here.
|
| + */
|
| + if( pPager->dbSize!=pPager->dbFileSize ){
|
| + Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
|
| + assert( pPager->eState==PAGER_WRITER_DBMOD );
|
| + rc = pager_truncate(pPager, nNew);
|
| + if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
|
| + }
|
| +
|
| + /* Finally, sync the database file. */
|
| + if( !noSync ){
|
| + rc = sqlite3PagerSync(pPager);
|
| + }
|
| + IOTRACE(("DBSYNC %p\n", pPager))
|
| }
|
| -
|
| - /* Finally, sync the database file. */
|
| - if( !pPager->noSync && !noSync ){
|
| - rc = sqlite3OsSync(pPager->fd, pPager->sync_flags);
|
| - }
|
| - IOTRACE(("DBSYNC %p\n", pPager))
|
| -
|
| - pPager->state = PAGER_SYNCED;
|
| }
|
|
|
| commit_phase_one_exit:
|
| + if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
|
| + pPager->eState = PAGER_WRITER_FINISHED;
|
| + }
|
| return rc;
|
| }
|
|
|
| @@ -4756,11 +5952,11 @@ int sqlite3PagerCommitPhaseTwo(Pager *pPager){
|
| ** called, just return the same error code without doing anything. */
|
| if( NEVER(pPager->errCode) ) return pPager->errCode;
|
|
|
| - /* This function should not be called if the pager is not in at least
|
| - ** PAGER_RESERVED state. And indeed SQLite never does this. But it is
|
| - ** nice to have this defensive test here anyway.
|
| - */
|
| - if( NEVER(pPager->state<PAGER_RESERVED) ) return SQLITE_ERROR;
|
| + assert( pPager->eState==PAGER_WRITER_LOCKED
|
| + || pPager->eState==PAGER_WRITER_FINISHED
|
| + || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
|
|
| /* An optimization. If the database was not actually modified during
|
| ** this transaction, the pager is running in exclusive-mode and is
|
| @@ -4773,95 +5969,86 @@ int sqlite3PagerCommitPhaseTwo(Pager *pPager){
|
| ** header. Since the pager is in exclusive mode, there is no need
|
| ** to drop any locks either.
|
| */
|
| - if( pPager->dbModified==0 && pPager->exclusiveMode
|
| + if( pPager->eState==PAGER_WRITER_LOCKED
|
| + && pPager->exclusiveMode
|
| && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
|
| ){
|
| - assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
|
| + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
|
| + pPager->eState = PAGER_READER;
|
| return SQLITE_OK;
|
| }
|
|
|
| PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
|
| - assert( pPager->state==PAGER_SYNCED || MEMDB || !pPager->dbModified );
|
| rc = pager_end_transaction(pPager, pPager->setMaster);
|
| return pager_error(pPager, rc);
|
| }
|
|
|
| /*
|
| -** Rollback all changes. The database falls back to PAGER_SHARED mode.
|
| +** If a write transaction is open, then all changes made within the
|
| +** transaction are reverted and the current write-transaction is closed.
|
| +** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
|
| +** state if an error occurs.
|
| +**
|
| +** If the pager is already in PAGER_ERROR state when this function is called,
|
| +** it returns Pager.errCode immediately. No work is performed in this case.
|
| **
|
| -** This function performs two tasks:
|
| +** Otherwise, in rollback mode, this function performs two functions:
|
| **
|
| ** 1) It rolls back the journal file, restoring all database file and
|
| ** in-memory cache pages to the state they were in when the transaction
|
| ** was opened, and
|
| +**
|
| ** 2) It finalizes the journal file, so that it is not used for hot
|
| ** rollback at any point in the future.
|
| **
|
| -** subject to the following qualifications:
|
| -**
|
| -** * If the journal file is not yet open when this function is called,
|
| -** then only (2) is performed. In this case there is no journal file
|
| -** to roll back.
|
| -**
|
| -** * If in an error state other than SQLITE_FULL, then task (1) is
|
| -** performed. If successful, task (2). Regardless of the outcome
|
| -** of either, the error state error code is returned to the caller
|
| -** (i.e. either SQLITE_IOERR or SQLITE_CORRUPT).
|
| -**
|
| -** * If the pager is in PAGER_RESERVED state, then attempt (1). Whether
|
| -** or not (1) is succussful, also attempt (2). If successful, return
|
| -** SQLITE_OK. Otherwise, enter the error state and return the first
|
| -** error code encountered.
|
| -**
|
| -** In this case there is no chance that the database was written to.
|
| -** So is safe to finalize the journal file even if the playback
|
| -** (operation 1) failed. However the pager must enter the error state
|
| -** as the contents of the in-memory cache are now suspect.
|
| +** Finalization of the journal file (task 2) is only performed if the
|
| +** rollback is successful.
|
| **
|
| -** * Finally, if in PAGER_EXCLUSIVE state, then attempt (1). Only
|
| -** attempt (2) if (1) is successful. Return SQLITE_OK if successful,
|
| -** otherwise enter the error state and return the error code from the
|
| -** failing operation.
|
| -**
|
| -** In this case the database file may have been written to. So if the
|
| -** playback operation did not succeed it would not be safe to finalize
|
| -** the journal file. It needs to be left in the file-system so that
|
| -** some other process can use it to restore the database state (by
|
| -** hot-journal rollback).
|
| +** In WAL mode, all cache-entries containing data modified within the
|
| +** current transaction are either expelled from the cache or reverted to
|
| +** their pre-transaction state by re-reading data from the database or
|
| +** WAL files. The WAL transaction is then closed.
|
| */
|
| int sqlite3PagerRollback(Pager *pPager){
|
| int rc = SQLITE_OK; /* Return code */
|
| PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
|
| - if( !pPager->dbModified || !isOpen(pPager->jfd) ){
|
| - rc = pager_end_transaction(pPager, pPager->setMaster);
|
| - }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){
|
| - if( pPager->state>=PAGER_EXCLUSIVE ){
|
| - pager_playback(pPager, 0);
|
| +
|
| + /* PagerRollback() is a no-op if called in READER or OPEN state. If
|
| + ** the pager is already in the ERROR state, the rollback is not
|
| + ** attempted here. Instead, the error code is returned to the caller.
|
| + */
|
| + assert( assert_pager_state(pPager) );
|
| + if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
|
| + if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
|
| +
|
| + if( pagerUseWal(pPager) ){
|
| + int rc2;
|
| + rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
|
| + rc2 = pager_end_transaction(pPager, pPager->setMaster);
|
| + if( rc==SQLITE_OK ) rc = rc2;
|
| + }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
|
| + int eState = pPager->eState;
|
| + rc = pager_end_transaction(pPager, 0);
|
| + if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
|
| + /* This can happen using journal_mode=off. Move the pager to the error
|
| + ** state to indicate that the contents of the cache may not be trusted.
|
| + ** Any active readers will get SQLITE_ABORT.
|
| + */
|
| + pPager->errCode = SQLITE_ABORT;
|
| + pPager->eState = PAGER_ERROR;
|
| + return rc;
|
| }
|
| - rc = pPager->errCode;
|
| }else{
|
| - if( pPager->state==PAGER_RESERVED ){
|
| - int rc2;
|
| - rc = pager_playback(pPager, 0);
|
| - rc2 = pager_end_transaction(pPager, pPager->setMaster);
|
| - if( rc==SQLITE_OK ){
|
| - rc = rc2;
|
| - }
|
| - }else{
|
| - rc = pager_playback(pPager, 0);
|
| - }
|
| + rc = pager_playback(pPager, 0);
|
| + }
|
|
|
| - if( !MEMDB ){
|
| - pPager->dbSizeValid = 0;
|
| - }
|
| + assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
|
| + assert( rc==SQLITE_OK || rc==SQLITE_FULL || (rc&0xFF)==SQLITE_IOERR );
|
|
|
| - /* If an error occurs during a ROLLBACK, we can no longer trust the pager
|
| - ** cache. So call pager_error() on the way out to make any error
|
| - ** persistent.
|
| - */
|
| - rc = pager_error(pPager, rc);
|
| - }
|
| - return rc;
|
| + /* If an error occurs during a ROLLBACK, we can no longer trust the pager
|
| + ** cache. So call pager_error() on the way out to make any error persistent.
|
| + */
|
| + return pager_error(pPager, rc);
|
| }
|
|
|
| /*
|
| @@ -4880,6 +6067,18 @@ int sqlite3PagerRefcount(Pager *pPager){
|
| }
|
|
|
| /*
|
| +** Return the approximate number of bytes of memory currently
|
| +** used by the pager and its associated cache.
|
| +*/
|
| +int sqlite3PagerMemUsed(Pager *pPager){
|
| + int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
|
| + + 5*sizeof(void*);
|
| + return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
|
| + + sqlite3MallocSize(pPager)
|
| + + pPager->pageSize;
|
| +}
|
| +
|
| +/*
|
| ** Return the number of references to the specified page.
|
| */
|
| int sqlite3PagerPageRefcount(DbPage *pPage){
|
| @@ -4895,8 +6094,8 @@ int *sqlite3PagerStats(Pager *pPager){
|
| a[0] = sqlite3PcacheRefCount(pPager->pPCache);
|
| a[1] = sqlite3PcachePagecount(pPager->pPCache);
|
| a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
|
| - a[3] = pPager->dbSizeValid ? (int) pPager->dbSize : -1;
|
| - a[4] = pPager->state;
|
| + a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
|
| + a[4] = pPager->eState;
|
| a[5] = pPager->errCode;
|
| a[6] = pPager->nHit;
|
| a[7] = pPager->nMiss;
|
| @@ -4928,15 +6127,13 @@ int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
|
| int rc = SQLITE_OK; /* Return code */
|
| int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
|
|
|
| + assert( pPager->eState>=PAGER_WRITER_LOCKED );
|
| + assert( assert_pager_state(pPager) );
|
| +
|
| if( nSavepoint>nCurrent && pPager->useJournal ){
|
| int ii; /* Iterator variable */
|
| PagerSavepoint *aNew; /* New Pager.aSavepoint array */
|
|
|
| - /* Either there is no active journal or the sub-journal is open or
|
| - ** the journal is always stored in memory */
|
| - assert( pPager->nSavepoint==0 || isOpen(pPager->sjfd) ||
|
| - pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
|
| -
|
| /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
|
| ** if the allocation fails. Otherwise, zero the new portion in case a
|
| ** malloc failure occurs while populating it in the for(...) loop below.
|
| @@ -4949,13 +6146,11 @@ int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
|
| }
|
| memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
|
| pPager->aSavepoint = aNew;
|
| - pPager->nSavepoint = nSavepoint;
|
|
|
| /* Populate the PagerSavepoint structures just allocated. */
|
| for(ii=nCurrent; ii<nSavepoint; ii++){
|
| - assert( pPager->dbSizeValid );
|
| aNew[ii].nOrig = pPager->dbSize;
|
| - if( isOpen(pPager->jfd) && ALWAYS(pPager->journalOff>0) ){
|
| + if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
|
| aNew[ii].iOffset = pPager->journalOff;
|
| }else{
|
| aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
|
| @@ -4965,10 +6160,12 @@ int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
|
| if( !aNew[ii].pInSavepoint ){
|
| return SQLITE_NOMEM;
|
| }
|
| + if( pagerUseWal(pPager) ){
|
| + sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
|
| + }
|
| + pPager->nSavepoint = ii+1;
|
| }
|
| -
|
| - /* Open the sub-journal, if it is not already opened. */
|
| - rc = openSubJournal(pPager);
|
| + assert( pPager->nSavepoint==nSavepoint );
|
| assertTruncateConstraint(pPager);
|
| }
|
|
|
| @@ -5006,12 +6203,12 @@ int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
|
| ** savepoint. If no errors occur, SQLITE_OK is returned.
|
| */
|
| int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
|
| - int rc = SQLITE_OK;
|
| + int rc = pPager->errCode; /* Return code */
|
|
|
| assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
|
| assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
|
|
|
| - if( iSavepoint<pPager->nSavepoint ){
|
| + if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
|
| int ii; /* Iterator variable */
|
| int nNew; /* Number of remaining savepoints after this op. */
|
|
|
| @@ -5019,31 +6216,36 @@ int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
|
| ** operation. Store this value in nNew. Then free resources associated
|
| ** with any savepoints that are destroyed by this operation.
|
| */
|
| - nNew = iSavepoint + (op==SAVEPOINT_ROLLBACK);
|
| + nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
|
| for(ii=nNew; ii<pPager->nSavepoint; ii++){
|
| sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
|
| }
|
| pPager->nSavepoint = nNew;
|
|
|
| - /* If this is a rollback operation, playback the specified savepoint.
|
| + /* If this is a release of the outermost savepoint, truncate
|
| + ** the sub-journal to zero bytes in size. */
|
| + if( op==SAVEPOINT_RELEASE ){
|
| + if( nNew==0 && isOpen(pPager->sjfd) ){
|
| + /* Only truncate if it is an in-memory sub-journal. */
|
| + if( sqlite3IsMemJournal(pPager->sjfd) ){
|
| + rc = sqlite3OsTruncate(pPager->sjfd, 0);
|
| + assert( rc==SQLITE_OK );
|
| + }
|
| + pPager->nSubRec = 0;
|
| + }
|
| + }
|
| + /* Else this is a rollback operation, playback the specified savepoint.
|
| ** If this is a temp-file, it is possible that the journal file has
|
| ** not yet been opened. In this case there have been no changes to
|
| ** the database file, so the playback operation can be skipped.
|
| */
|
| - if( op==SAVEPOINT_ROLLBACK && isOpen(pPager->jfd) ){
|
| + else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
|
| PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
|
| rc = pagerPlaybackSavepoint(pPager, pSavepoint);
|
| assert(rc!=SQLITE_DONE);
|
| }
|
| -
|
| - /* If this is a release of the outermost savepoint, truncate
|
| - ** the sub-journal to zero bytes in size. */
|
| - if( nNew==0 && op==SAVEPOINT_RELEASE && isOpen(pPager->sjfd) ){
|
| - assert( rc==SQLITE_OK );
|
| - rc = sqlite3OsTruncate(pPager->sjfd, 0);
|
| - pPager->nSubRec = 0;
|
| - }
|
| }
|
| +
|
| return rc;
|
| }
|
|
|
| @@ -5089,7 +6291,7 @@ int sqlite3PagerNosync(Pager *pPager){
|
| /*
|
| ** Set or retrieve the codec for this pager
|
| */
|
| -static void sqlite3PagerSetCodec(
|
| +void sqlite3PagerSetCodec(
|
| Pager *pPager,
|
| void *(*xCodec)(void*,void*,Pgno,int),
|
| void (*xCodecSizeChng)(void*,int,int),
|
| @@ -5097,13 +6299,13 @@ static void sqlite3PagerSetCodec(
|
| void *pCodec
|
| ){
|
| if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
|
| - pPager->xCodec = xCodec;
|
| + pPager->xCodec = pPager->memDb ? 0 : xCodec;
|
| pPager->xCodecSizeChng = xCodecSizeChng;
|
| pPager->xCodecFree = xCodecFree;
|
| pPager->pCodec = pCodec;
|
| pagerReportSize(pPager);
|
| }
|
| -static void *sqlite3PagerGetCodec(Pager *pPager){
|
| +void *sqlite3PagerGetCodec(Pager *pPager){
|
| return pPager->pCodec;
|
| }
|
| #endif
|
| @@ -5141,6 +6343,18 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| Pgno origPgno; /* The original page number */
|
|
|
| assert( pPg->nRef>0 );
|
| + assert( pPager->eState==PAGER_WRITER_CACHEMOD
|
| + || pPager->eState==PAGER_WRITER_DBMOD
|
| + );
|
| + assert( assert_pager_state(pPager) );
|
| +
|
| + /* In order to be able to rollback, an in-memory database must journal
|
| + ** the page we are moving from.
|
| + */
|
| + if( MEMDB ){
|
| + rc = sqlite3PagerWrite(pPg);
|
| + if( rc ) return rc;
|
| + }
|
|
|
| /* If the page being moved is dirty and has not been saved by the latest
|
| ** savepoint, then save the current contents of the page into the
|
| @@ -5160,7 +6374,7 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| ** one or more savepoint bitvecs. This is the reason this function
|
| ** may return SQLITE_NOMEM.
|
| */
|
| - if( pPg->flags&PGHDR_DIRTY
|
| + if( pPg->flags&PGHDR_DIRTY
|
| && subjRequiresPage(pPg)
|
| && SQLITE_OK!=(rc = subjournalPage(pPg))
|
| ){
|
| @@ -5182,11 +6396,10 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| needSyncPgno = pPg->pgno;
|
| assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
|
| assert( pPg->flags&PGHDR_DIRTY );
|
| - assert( pPager->needSync );
|
| }
|
|
|
| /* If the cache contains a page with page-number pgno, remove it
|
| - ** from its hash chain. Also, if the PgHdr.needSync was set for
|
| + ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
|
| ** page pgno before the 'move' operation, it needs to be retained
|
| ** for the page moved there.
|
| */
|
| @@ -5195,20 +6408,35 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| assert( !pPgOld || pPgOld->nRef==1 );
|
| if( pPgOld ){
|
| pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
|
| - sqlite3PcacheDrop(pPgOld);
|
| + if( MEMDB ){
|
| + /* Do not discard pages from an in-memory database since we might
|
| + ** need to rollback later. Just move the page out of the way. */
|
| + sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
|
| + }else{
|
| + sqlite3PcacheDrop(pPgOld);
|
| + }
|
| }
|
|
|
| origPgno = pPg->pgno;
|
| sqlite3PcacheMove(pPg, pgno);
|
| sqlite3PcacheMakeDirty(pPg);
|
| - pPager->dbModified = 1;
|
| +
|
| + /* For an in-memory database, make sure the original page continues
|
| + ** to exist, in case the transaction needs to roll back. Use pPgOld
|
| + ** as the original page since it has already been allocated.
|
| + */
|
| + if( MEMDB ){
|
| + assert( pPgOld );
|
| + sqlite3PcacheMove(pPgOld, origPgno);
|
| + sqlite3PagerUnref(pPgOld);
|
| + }
|
|
|
| if( needSyncPgno ){
|
| /* If needSyncPgno is non-zero, then the journal file needs to be
|
| ** sync()ed before any data is written to database file page needSyncPgno.
|
| ** Currently, no such page exists in the page-cache and the
|
| ** "is journaled" bitvec flag has been set. This needs to be remedied by
|
| - ** loading the page into the pager-cache and setting the PgHdr.needSync
|
| + ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
|
| ** flag.
|
| **
|
| ** If the attempt to load the page into the page-cache fails, (due
|
| @@ -5217,12 +6445,8 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| ** this transaction, it may be written to the database file before
|
| ** it is synced into the journal file. This way, it may end up in
|
| ** the journal file twice, but that is not a problem.
|
| - **
|
| - ** The sqlite3PagerGet() call may cause the journal to sync. So make
|
| - ** sure the Pager.needSync flag is set too.
|
| */
|
| PgHdr *pPgHdr;
|
| - assert( pPager->needSync );
|
| rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
|
| if( rc!=SQLITE_OK ){
|
| if( needSyncPgno<=pPager->dbOrigSize ){
|
| @@ -5231,29 +6455,11 @@ int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
|
| }
|
| return rc;
|
| }
|
| - pPager->needSync = 1;
|
| - assert( pPager->noSync==0 && !MEMDB );
|
| pPgHdr->flags |= PGHDR_NEED_SYNC;
|
| sqlite3PcacheMakeDirty(pPgHdr);
|
| sqlite3PagerUnref(pPgHdr);
|
| }
|
|
|
| - /*
|
| - ** For an in-memory database, make sure the original page continues
|
| - ** to exist, in case the transaction needs to roll back. We allocate
|
| - ** the page now, instead of at rollback, because we can better deal
|
| - ** with an out-of-memory error now. Ticket #3761.
|
| - */
|
| - if( MEMDB ){
|
| - DbPage *pNew;
|
| - rc = sqlite3PagerAcquire(pPager, origPgno, &pNew, 1);
|
| - if( rc!=SQLITE_OK ){
|
| - sqlite3PcacheMove(pPg, origPgno);
|
| - return rc;
|
| - }
|
| - sqlite3PagerUnref(pNew);
|
| - }
|
| -
|
| return SQLITE_OK;
|
| }
|
| #endif
|
| @@ -5375,56 +6581,146 @@ int sqlite3PagerLockingMode(Pager *pPager, int eMode){
|
| || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
|
| assert( PAGER_LOCKINGMODE_QUERY<0 );
|
| assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
|
| - if( eMode>=0 && !pPager->tempFile ){
|
| + assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
|
| + if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
|
| pPager->exclusiveMode = (u8)eMode;
|
| }
|
| return (int)pPager->exclusiveMode;
|
| }
|
|
|
| /*
|
| -** Get/set the journal-mode for this pager. Parameter eMode must be one of:
|
| +** Set the journal-mode for this pager. Parameter eMode must be one of:
|
| **
|
| -** PAGER_JOURNALMODE_QUERY
|
| ** PAGER_JOURNALMODE_DELETE
|
| ** PAGER_JOURNALMODE_TRUNCATE
|
| ** PAGER_JOURNALMODE_PERSIST
|
| ** PAGER_JOURNALMODE_OFF
|
| ** PAGER_JOURNALMODE_MEMORY
|
| +** PAGER_JOURNALMODE_WAL
|
| **
|
| -** If the parameter is not _QUERY, then the journal_mode is set to the
|
| -** value specified if the change is allowed. The change is disallowed
|
| -** for the following reasons:
|
| +** The journalmode is set to the value specified if the change is allowed.
|
| +** The change may be disallowed for the following reasons:
|
| **
|
| ** * An in-memory database can only have its journal_mode set to _OFF
|
| ** or _MEMORY.
|
| **
|
| -** * The journal mode may not be changed while a transaction is active.
|
| +** * Temporary databases cannot have _WAL journalmode.
|
| **
|
| ** The returned indicate the current (possibly updated) journal-mode.
|
| */
|
| -int sqlite3PagerJournalMode(Pager *pPager, int eMode){
|
| - assert( eMode==PAGER_JOURNALMODE_QUERY
|
| - || eMode==PAGER_JOURNALMODE_DELETE
|
| +int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
|
| + u8 eOld = pPager->journalMode; /* Prior journalmode */
|
| +
|
| +#ifdef SQLITE_DEBUG
|
| + /* The print_pager_state() routine is intended to be used by the debugger
|
| + ** only. We invoke it once here to suppress a compiler warning. */
|
| + print_pager_state(pPager);
|
| +#endif
|
| +
|
| +
|
| + /* The eMode parameter is always valid */
|
| + assert( eMode==PAGER_JOURNALMODE_DELETE
|
| || eMode==PAGER_JOURNALMODE_TRUNCATE
|
| || eMode==PAGER_JOURNALMODE_PERSIST
|
| || eMode==PAGER_JOURNALMODE_OFF
|
| + || eMode==PAGER_JOURNALMODE_WAL
|
| || eMode==PAGER_JOURNALMODE_MEMORY );
|
| - assert( PAGER_JOURNALMODE_QUERY<0 );
|
| - if( eMode>=0
|
| - && (!MEMDB || eMode==PAGER_JOURNALMODE_MEMORY
|
| - || eMode==PAGER_JOURNALMODE_OFF)
|
| - && !pPager->dbModified
|
| - && (!isOpen(pPager->jfd) || 0==pPager->journalOff)
|
| - ){
|
| - if( isOpen(pPager->jfd) ){
|
| - sqlite3OsClose(pPager->jfd);
|
| +
|
| + /* This routine is only called from the OP_JournalMode opcode, and
|
| + ** the logic there will never allow a temporary file to be changed
|
| + ** to WAL mode.
|
| + */
|
| + assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
|
| +
|
| + /* Do allow the journalmode of an in-memory database to be set to
|
| + ** anything other than MEMORY or OFF
|
| + */
|
| + if( MEMDB ){
|
| + assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
|
| + if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
|
| + eMode = eOld;
|
| }
|
| + }
|
| +
|
| + if( eMode!=eOld ){
|
| +
|
| + /* Change the journal mode. */
|
| + assert( pPager->eState!=PAGER_ERROR );
|
| pPager->journalMode = (u8)eMode;
|
| +
|
| + /* When transistioning from TRUNCATE or PERSIST to any other journal
|
| + ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
|
| + ** delete the journal file.
|
| + */
|
| + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
|
| + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
|
| + assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
|
| + assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
|
| + assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
|
| + assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
|
| +
|
| + assert( isOpen(pPager->fd) || pPager->exclusiveMode );
|
| + if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
|
| +
|
| + /* In this case we would like to delete the journal file. If it is
|
| + ** not possible, then that is not a problem. Deleting the journal file
|
| + ** here is an optimization only.
|
| + **
|
| + ** Before deleting the journal file, obtain a RESERVED lock on the
|
| + ** database file. This ensures that the journal file is not deleted
|
| + ** while it is in use by some other client.
|
| + */
|
| + sqlite3OsClose(pPager->jfd);
|
| + if( pPager->eLock>=RESERVED_LOCK ){
|
| + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
|
| + }else{
|
| + int rc = SQLITE_OK;
|
| + int state = pPager->eState;
|
| + assert( state==PAGER_OPEN || state==PAGER_READER );
|
| + if( state==PAGER_OPEN ){
|
| + rc = sqlite3PagerSharedLock(pPager);
|
| + }
|
| + if( pPager->eState==PAGER_READER ){
|
| + assert( rc==SQLITE_OK );
|
| + rc = pagerLockDb(pPager, RESERVED_LOCK);
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
|
| + }
|
| + if( rc==SQLITE_OK && state==PAGER_READER ){
|
| + pagerUnlockDb(pPager, SHARED_LOCK);
|
| + }else if( state==PAGER_OPEN ){
|
| + pager_unlock(pPager);
|
| + }
|
| + assert( state==pPager->eState );
|
| + }
|
| + }
|
| }
|
| +
|
| + /* Return the new journal mode */
|
| return (int)pPager->journalMode;
|
| }
|
|
|
| /*
|
| +** Return the current journal mode.
|
| +*/
|
| +int sqlite3PagerGetJournalMode(Pager *pPager){
|
| + return (int)pPager->journalMode;
|
| +}
|
| +
|
| +/*
|
| +** Return TRUE if the pager is in a state where it is OK to change the
|
| +** journalmode. Journalmode changes can only happen when the database
|
| +** is unmodified.
|
| +*/
|
| +int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
|
| + assert( assert_pager_state(pPager) );
|
| + if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
|
| + if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
|
| + return 1;
|
| +}
|
| +
|
| +/*
|
| ** Get/set the size-limit used for persistent journal files.
|
| **
|
| ** Setting the size limit to -1 means no limit is enforced.
|
| @@ -5447,4 +6743,196 @@ sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
|
| return &pPager->pBackup;
|
| }
|
|
|
| +#ifndef SQLITE_OMIT_WAL
|
| +/*
|
| +** This function is called when the user invokes "PRAGMA wal_checkpoint",
|
| +** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
|
| +** or wal_blocking_checkpoint() API functions.
|
| +**
|
| +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
|
| +*/
|
| +int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
|
| + int rc = SQLITE_OK;
|
| + if( pPager->pWal ){
|
| + rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
|
| + pPager->xBusyHandler, pPager->pBusyHandlerArg,
|
| + pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
|
| + pnLog, pnCkpt
|
| + );
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +int sqlite3PagerWalCallback(Pager *pPager){
|
| + return sqlite3WalCallback(pPager->pWal);
|
| +}
|
| +
|
| +/*
|
| +** Return true if the underlying VFS for the given pager supports the
|
| +** primitives necessary for write-ahead logging.
|
| +*/
|
| +int sqlite3PagerWalSupported(Pager *pPager){
|
| + const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
|
| + return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
|
| +}
|
| +
|
| +/*
|
| +** Attempt to take an exclusive lock on the database file. If a PENDING lock
|
| +** is obtained instead, immediately release it.
|
| +*/
|
| +static int pagerExclusiveLock(Pager *pPager){
|
| + int rc; /* Return code */
|
| +
|
| + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
|
| + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
|
| + if( rc!=SQLITE_OK ){
|
| + /* If the attempt to grab the exclusive lock failed, release the
|
| + ** pending lock that may have been obtained instead. */
|
| + pagerUnlockDb(pPager, SHARED_LOCK);
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
|
| +** exclusive-locking mode when this function is called, take an EXCLUSIVE
|
| +** lock on the database file and use heap-memory to store the wal-index
|
| +** in. Otherwise, use the normal shared-memory.
|
| +*/
|
| +static int pagerOpenWal(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( pPager->pWal==0 && pPager->tempFile==0 );
|
| + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK || pPager->noReadlock);
|
| +
|
| + /* If the pager is already in exclusive-mode, the WAL module will use
|
| + ** heap-memory for the wal-index instead of the VFS shared-memory
|
| + ** implementation. Take the exclusive lock now, before opening the WAL
|
| + ** file, to make sure this is safe.
|
| + */
|
| + if( pPager->exclusiveMode ){
|
| + rc = pagerExclusiveLock(pPager);
|
| + }
|
| +
|
| + /* Open the connection to the log file. If this operation fails,
|
| + ** (e.g. due to malloc() failure), return an error code.
|
| + */
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3WalOpen(pPager->pVfs,
|
| + pPager->fd, pPager->zWal, pPager->exclusiveMode, &pPager->pWal
|
| + );
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** The caller must be holding a SHARED lock on the database file to call
|
| +** this function.
|
| +**
|
| +** If the pager passed as the first argument is open on a real database
|
| +** file (not a temp file or an in-memory database), and the WAL file
|
| +** is not already open, make an attempt to open it now. If successful,
|
| +** return SQLITE_OK. If an error occurs or the VFS used by the pager does
|
| +** not support the xShmXXX() methods, return an error code. *pbOpen is
|
| +** not modified in either case.
|
| +**
|
| +** If the pager is open on a temp-file (or in-memory database), or if
|
| +** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
|
| +** without doing anything.
|
| +*/
|
| +int sqlite3PagerOpenWal(
|
| + Pager *pPager, /* Pager object */
|
| + int *pbOpen /* OUT: Set to true if call is a no-op */
|
| +){
|
| + int rc = SQLITE_OK; /* Return code */
|
| +
|
| + assert( assert_pager_state(pPager) );
|
| + assert( pPager->eState==PAGER_OPEN || pbOpen );
|
| + assert( pPager->eState==PAGER_READER || !pbOpen );
|
| + assert( pbOpen==0 || *pbOpen==0 );
|
| + assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
|
| +
|
| + if( !pPager->tempFile && !pPager->pWal ){
|
| + if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
|
| +
|
| + /* Close any rollback journal previously open */
|
| + sqlite3OsClose(pPager->jfd);
|
| +
|
| + rc = pagerOpenWal(pPager);
|
| + if( rc==SQLITE_OK ){
|
| + pPager->journalMode = PAGER_JOURNALMODE_WAL;
|
| + pPager->eState = PAGER_OPEN;
|
| + }
|
| + }else{
|
| + *pbOpen = 1;
|
| + }
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This function is called to close the connection to the log file prior
|
| +** to switching from WAL to rollback mode.
|
| +**
|
| +** Before closing the log file, this function attempts to take an
|
| +** EXCLUSIVE lock on the database file. If this cannot be obtained, an
|
| +** error (SQLITE_BUSY) is returned and the log connection is not closed.
|
| +** If successful, the EXCLUSIVE lock is not released before returning.
|
| +*/
|
| +int sqlite3PagerCloseWal(Pager *pPager){
|
| + int rc = SQLITE_OK;
|
| +
|
| + assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
|
| +
|
| + /* If the log file is not already open, but does exist in the file-system,
|
| + ** it may need to be checkpointed before the connection can switch to
|
| + ** rollback mode. Open it now so this can happen.
|
| + */
|
| + if( !pPager->pWal ){
|
| + int logexists = 0;
|
| + rc = pagerLockDb(pPager, SHARED_LOCK);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3OsAccess(
|
| + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
|
| + );
|
| + }
|
| + if( rc==SQLITE_OK && logexists ){
|
| + rc = pagerOpenWal(pPager);
|
| + }
|
| + }
|
| +
|
| + /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
|
| + ** the database file, the log and log-summary files will be deleted.
|
| + */
|
| + if( rc==SQLITE_OK && pPager->pWal ){
|
| + rc = pagerExclusiveLock(pPager);
|
| + if( rc==SQLITE_OK ){
|
| + rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
|
| + pPager->pageSize, (u8*)pPager->pTmpSpace);
|
| + pPager->pWal = 0;
|
| + }
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +#ifdef SQLITE_HAS_CODEC
|
| +/*
|
| +** This function is called by the wal module when writing page content
|
| +** into the log file.
|
| +**
|
| +** This function returns a pointer to a buffer containing the encrypted
|
| +** page content. If a malloc fails, this function may return NULL.
|
| +*/
|
| +void *sqlite3PagerCodec(PgHdr *pPg){
|
| + void *aData = 0;
|
| + CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
|
| + return aData;
|
| +}
|
| +#endif /* SQLITE_HAS_CODEC */
|
| +
|
| +#endif /* !SQLITE_OMIT_WAL */
|
| +
|
| #endif /* SQLITE_OMIT_DISKIO */
|
|
|
Chromium Code Reviews
