Lines Matching defs:mode
564 ** See the [threading mode] documentation for additional information.
1271 ** closes. Setting persistent WAL mode causes those files to persist after
1277 ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
1278 ** WAL mode. If the integer is -1, then it is overwritten with the current
1287 ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
1288 ** mode. If the integer is -1, then it is overwritten with the current
1289 ** zero-damage mode setting.
1418 ** the file descriptor is placed in "batch write mode", which
1436 ** the file descriptor out of batch write mode so that all subsequent
1445 ** ^This file control takes the file descriptor out of batch write mode
1480 ** in wal mode before the client starts to copy pages from the wal
1485 ** in wal mode after the client has finished copying pages from the wal
1492 ** whether or not there is a database client in another process with a wal-mode
1496 ** mode database and there exists at least one client in another process that
1498 ** the database is not a wal-mode db, or if there is no such connection in any
2099 ** [threading mode] to Single-thread. In other words, it disables
2100 ** all mutexing and puts SQLite into a mode where it can only be used
2103 ** it is not possible to change the [threading mode] from its default
2110 ** [threading mode] to Multi-thread. In other words, it disables
2118 ** it is not possible to set the Multi-thread [threading mode] and
2124 ** [threading mode] to Serialized. In other words, this option enables
2127 ** In this mode (which is the default when SQLite is compiled with
2134 ** it is not possible to set the Serialized [threading mode] and
2590 ** <dd> Usually, when a database in wal mode is closed or detached from a
2640 ** the database in WAL mode after the reset if it was in WAL mode before
3476 ** Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
3734 ** <dd>The database is opened in read-only mode. If the database does not
3758 ** if shared cache mode is enabled, but the "filename" is otherwise ignored.
3763 ** [threading mode].)^ This means that separate threads are allowed
3769 ** [threading mode].)^ This means the multiple threads can safely
3771 ** (Mutexes will block any actual concurrency, but in this mode
3778 ** The [use of shared cache mode is discouraged] and hence shared cache
3788 ** <dd>The database connection comes up in "extended result code mode".
3792 ** the extended result code mode, this flag also causes [sqlite3_open_v2()]
3871 ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw",
3876 ** third argument to sqlite3_open_v2(). ^If the mode option is set to
3880 ** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is
3883 ** the mode parameter that is less restrictive than that specified by
3941 ** <tr><td> file:data.db?mode=ro&cache=private <td>
3943 ** Regardless of whether or not shared-cache mode is enabled by
3948 ** <tr><td> file:data.db?mode=readonly <td>
3949 ** An error. "readonly" is not a valid option for the "mode" parameter.
3950 ** Use "ro" instead: "file:data.db?mode=ro".
4094 ** ^If X is the name of a rollback or WAL-mode journal file that is
4210 ** When the serialized [threading mode] is in use, it might be the
6651 ** KEYWORDS: {autocommit mode}
6655 ** zero if the given database connection is or is not in autocommit mode,
6656 ** respectively. ^Autocommit mode is on by default.
6657 ** ^Autocommit mode is disabled by a [BEGIN] statement.
6658 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
6999 ** [use of shared cache mode is discouraged].
7006 ** ^(The cache sharing mode set by this interface effects all subsequent
7008 ** Existing database connections continue to use the sharing mode
7024 ** shared cache mode should be enabled per-database connection via
7920 ** the database is in auto-commit mode and there are no other open read-write
8323 ** when the [threading mode] is Serialized.
8324 ** ^If the [threading mode] is Single-thread or Multi-thread then this
8819 ** [shared cache mode] being enabled.
8844 ** wal file in wal mode databases, or the number of pages written to the
8845 ** database file in rollback mode databases. Any pages written as part of
9396 ** If running in [shared cache mode], the application must
9425 ** ^When running in shared-cache mode, a database operation may fail with
9622 ** is invoked each time data is committed to a database in wal mode.
9716 ** operation on database X of [database connection] D in mode M. Status
9718 ** ^(The M parameter must be a valid [checkpoint mode]:)^
9725 ** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode.
9726 ** ^On the other hand, passive mode might leave the checkpoint unfinished
9730 ** ^This mode blocks (it invokes the
9734 ** database file. ^This mode blocks new database writers while it is pending,
9738 ** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition
9743 ** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new
9747 ** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the
9754 ** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not
9758 ** because the database is not in WAL mode. ^Note that upon successful
9791 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
9813 ** KEYWORDS: {checkpoint mode}
9815 ** These constants define all valid values for the "checkpoint mode" passed
9865 ** ON CONFLICT mode specified.
9870 ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
9873 ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
9874 ** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
9917 ** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
10032 ** "aOrderBy" field are adjacent.)^ This mode is used when the query planner
10045 ** This mode is used for a DISTINCT query.
10051 ** it is not required to omit any rows. This mode is used for queries
10092 ** the usual mode of handling IN operators, SQLite generates [bytecode]
10244 ** KEYWORDS: {conflict resolution mode}
10247 ** inform a [virtual table] implementation what the [ON CONFLICT] mode
10526 ** An instance of the snapshot object records the state of a [WAL mode]
10529 ** In [WAL mode], multiple [database connections] that are open on the
10564 ** <li> The database handle must not be in [autocommit mode].
10566 ** <li> Schema S of [database connection] D must be a [WAL mode] database.
10573 ** that a snapshot cannot be taken on a wal mode database with no wal
10579 ** database handle in autocommit mode but fails for some other reason,
10607 ** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there
10628 ** schema S is in [WAL mode]. A database connection might not know
10629 ** that the database file is in [WAL mode] if there has been no prior
10630 ** I/O on that database connection, or if the database entered [WAL mode]
10670 ** database is changed back to rollback mode or when the number of database
10702 ** transaction open on the database, or if the database is not a WAL mode
13400 ** checkpointing the database in WAL mode.
13514 ** WAL mode depends on atomic aligned 32-bit loads and stores in a few
16801 ** In shared cache mode, a single Schema object can be shared by multiple
16871 ** be stored in lookaside because in shared cache mode the schema information
17033 u8 dfltLockMode; /* Default locking-mode for attached dbs */
17824 #define TF_Strict 0x00010000 /* STRICT mode */
18193 u8 directMode; /* Direct rendering mode means take data directly
18195 u8 useSortingIdx; /* In direct mode, reference the sorting index rather
19147 TableLock *aTableLock; /* Required table locks for shared-cache mode */
19495 int sharedCacheEnabled; /* true if shared-cache mode enabled */
27610 ** apps that usually use SQLITE_CONFIG_MULTITHREAD mode.
29277 ** mode and specifically when the DMD "Dark Matter Detector" is enabled
30085 ** Set the StrAccum object to an error mode.
32845 /* This routine is never used in single-threaded mode */
37038 /* In test mode, increase the size of this structure a bit so that
37056 #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
37163 static int posixOpen(const char *zFile, int flags, int mode){
37164 int fd = open(zFile, flags, mode);
37477 ** If the file creation mode "m" is 0 then set it to the default for
37480 ** make the file creation mode be exactly m ignoring the umask.
38994 ** This locking mode is appropriate for use on read-only databases
38999 ** corruption if this locking mode is used in situations where multiple
39041 ** Nevertheless, a dotlock is an appropriate locking mode for use if no
41219 ** wal-mode transactions in other processes on database file pFile. If
42862 ** Find the mode, uid and gid of file zFile.
42901 ** the default permissions. In 8_3_NAMES mode, leave *pMode set to zero.
42931 ** a '-' character. However in 8+3 filename mode, or if a corrupt
42951 ** its value as a filename and try to copy the mode, uid and gid from
43153 ** (probably because SQLite is configured to use 8+3 filename mode) and
44742 ** switching proxy locking mode off then it will need to fail if
44743 ** the journal mode is WAL mode.
45102 ** Compiling and using WAL mode requires several APIs that are only
45106 # error "WAL mode requires support from the Windows NT kernel, compile\
45261 ** mode or memory mapped files (e.g. these APIs are available in the Windows
45380 #define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
47423 /* The following blocks should probably assert in debug mode, but they
48535 ** This locking mode is appropriate for use on read-only databases
48540 ** corruption if this locking mode is used in situations where multiple
50090 int flags, /* Open mode flags */
51598 ** In rollback mode (which is always the case for memdb, as it does not
51599 ** support WAL mode) the truncate() method is only used to reduce
51607 /* This can only happen with a corrupt wal mode db */
53688 ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
53751 PGroup grp; /* The global PGroup for mode (2) */
54239 ** private PGroup (mode-1). pcache1.separateCache is false if the single
54240 ** PGroup in pcache1.grp is used for all page caches (mode-2).
54242 ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
54249 ** * Otherwise use separate caches (mode-1)
55666 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
55667 ** was) in exclusive-locking mode, a user-level read transaction is
55694 ** In rollback mode, a RESERVED or (if the transaction was opened with
55701 ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
55706 ** * If the connection is open in rollback-mode, a RESERVED or greater
55708 ** * If the connection is open in WAL-mode, a WAL write transaction
55719 ** first modified by the upper layer. In rollback mode the journal file
55747 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
55822 ** connection is open in WAL mode. A WAL connection is always in one
55825 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
55826 ** state. There are two exceptions: immediately after exclusive-mode has
55983 ** This mechanism means that when running in exclusive mode, a connection
55995 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
56000 ** running in "journal_mode=truncate" mode.
56105 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
56111 ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
56125 u8 noLock; /* Do not lock (except in WAL mode) */
56134 ** significant mode change (such as changing the page_size, locking_mode,
56373 /* If the useJournal flag is clear, the journal-mode must be "OFF".
56374 ** And if the journal-mode is "OFF", the journal file must not be open.
56505 "Locking mode: locking_mode=%s\n"
56506 "Journal mode: journal_mode=%s\n"
56886 ** if the pager is not in no-sync mode, sync the journal file immediately
56940 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
56977 ** if in full-sync mode), the zero is overwritten with the true number
56987 ** * When the pager is in no-sync mode. Corruption can follow a
57175 ** thing written to a journal file. If the pager is in full-sync mode, the
57215 /* If in full-sync mode, advance to the next disk sector before writing
57238 /* If the pager is in peristent-journal mode, then the physical
57275 ** if it is open and the pager is not in exclusive mode.
57312 ** This function is a no-op if the pager is in exclusive mode and not
57316 ** If the pager is not in exclusive-access mode, the database file is
57323 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
57385 ** normal and exclusive-locking mode.
57483 ** depends on whether or not the pager is running in exclusive mode and
57484 ** the current journal-mode (Pager.journalMode value), as follows:
57501 ** If the pager is running in exclusive mode, this method of finalizing
57503 ** DELETE and the pager is in exclusive mode, the method described under
57507 ** If running in non-exclusive rollback mode, the lock on the file is
57514 ** tries to unlock the database file if not in exclusive mode. If the
57617 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
57624 ** mode if the database file on disk is larger than the database image.
57863 ** An exception to the above rule: If the database is in no-sync mode
57954 ** obscure. When running in synchronous mode, this can only happen
58373 ** working in no-sync mode. This means that the rest of the journal
58469 ** mode, then subsequent transactions performed by the connection will not
58837 ** in WAL mode. If the database is empty or if no *-wal file exists and
59093 ** single disk sector is atomic, then this mode provides
59101 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
59106 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
59109 ** and EXTRA for WAL mode.
59403 ** to WAL mode yet.
59758 ** Otherwise, the actions required depend on the journal-mode and the
59768 ** mode, then the journal file is synced before this field is updated.
59777 ** if( <full-sync mode> ) xSync(<journal file>);
59808 ** mode, then the journal file may at this point actually be larger
59846 ** full-synchronous mode, sync the journal first. This ensures that
59888 /* Unless the pager is in noSync mode, the journal file was just
60258 int memJM = 0; /* Memory journal mode */
60522 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
60766 ** 2) If the pager is running in exclusive-mode, and there are currently
60782 ** exclusive access mode. */
60827 ** Unless the pager is in locking_mode=exclusive mode, the lock is
60837 ** in exclusive-access mode the file descriptor will be kept open
60840 ** mode (and also for journal_mode=truncate on some systems).
60956 ** mode. Otherwise, the following function call is a no-op.
61327 ** If the journal file is already open (as it may be in exclusive mode),
61424 ** running in exclusive mode) or if the transaction does not require a
61472 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
61477 ** WAL mode.
61860 ** operating in direct-mode, make page 1 writable. When not in
61861 ** direct mode, page 1 is always held in cache and hence the PagerGet()
61872 /* If running in direct mode, write the contents of page 1 to the file. */
61921 ** rollback. If the connection is in WAL mode, this call is a no-op.
61926 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
62053 ** counter in 'indirect-mode'. If the optimization is compiled in but
62057 ** mode.
62061 ** in 'direct' mode. In this case the journal file will never be
62218 ** this transaction, the pager is running in exclusive-mode and is
62225 ** header. Since the pager is in exclusive mode, there is no need
62251 ** Otherwise, in rollback mode, this function performs two functions:
62263 ** In WAL mode, all cache-entries containing data modified within the
62857 ** Get/set the locking-mode for this pager. Parameter eMode must be one
62860 ** the locking-mode is set to the value specified.
62864 ** locking-mode.
62880 ** Set the journal-mode for this pager. Parameter eMode must be one of:
62897 ** The returned indicate the current (possibly updated) journal-mode.
62912 ** to WAL mode.
62928 /* Change the journal mode. */
62933 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
62982 /* Return the new journal mode */
62987 ** Return the current journal mode.
63113 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
63123 /* If the pager is already in exclusive-mode, the WAL module will use
63194 ** to switching from WAL to rollback mode.
63208 ** rollback mode. Open it now so this can happen.
63241 ** If pager pPager is a wal-mode database not in exclusive locking mode,
63347 ** the pager is in WAL mode and the WAL file currently contains one or more
63375 ** "journal_mode=WAL" mode.
63879 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
64838 int bNoShm, /* True to run in heap-memory mode */
65376 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
65424 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
65556 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as
65615 ** ordinary, rollback-mode locking methods, this guarantees that the
65639 ** mode (!bPersist) */
65644 ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
67246 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
67373 ** transition out of exclusive-mode is successful, return 1. This
67380 ** WAL is already in exclusive-locking mode - meaning that this
67396 ** happen if the connection is actually in exclusive mode (as no xShmLock
67398 ** upgrade to exclusive-mode following such an error.
67644 ** 64 4 Incremental vacuum mode
68989 ** by a connection in read-uncommitted mode is on the sqlite_schema
69116 ** database connetion. This is important in shared-cache mode. If the database
71065 ** and we are in shared cache mode, then the open will fail with an
71190 /* In debug mode, we mark all persistent databases as sharable
71248 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
71605 ** and autovacuum mode can no longer be changed.
71728 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
71864 ** in WAL mode. If the log is not already open, open it now. Then
73574 ** mode, the following events may invalidate an overflow page-list cache.
73577 ** * A commit in auto_vacuum="full" mode,
75393 ** freePage2() may zero the page contents if secure-delete mode is
76619 ** But not if we are in secure-delete mode. In secure-delete mode,
80093 int destMode; /* Destination journal mode */
80150 /* Do not allow backup if the destination database is in WAL mode
84415 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
84421 ** If SQLite is not threadsafe but does support shared-cache mode, then
84426 ** If SQLite is not threadsafe and does not support shared-cache mode, this
84765 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
85328 ** its journal mode (among other things). This matrix determines which
85673 ** has made changes and is in autocommit mode, then commit those
91251 /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
94242 ** connection is currently not in autocommit mode, or if there are other
94518 ** in read/write mode.
95836 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
96734 ** this (self-correcting and non-critical) error if in writable_schema mode.
98005 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
98042 ** Change the journal mode of database P1 to P3. P3 must be one of the
98047 ** If changing into or out of WAL mode the procedure is more complicated.
98049 ** Write a string containing the final journal-mode to register P2.
98052 Btree *pBt; /* Btree to change journal mode of */
98054 int eNew; /* New journal mode */
98055 int eOld; /* The old journal mode */
98099 "cannot change %s wal mode from within a transaction",
98106 /* If leaving WAL mode, close the log file. If successful, the call
98116 /* Cannot transition directly from MEMORY to WAL. Use mode OFF
98122 ** mode, this transaction always uses a rollback journal.
99867 ** If the sorter is running in single-threaded mode, then all PMAs generated
99869 ** multi-threaded mode then up to (N+1) temporary files may be opened, where
99876 ** The sorter is running in multi-threaded mode if (a) the library was built
99886 ** sorter is running in single-threaded mode, then these PMAs are merged
99891 ** Or, if running in multi-threaded mode, then a background thread is
99907 ** If running in multi-threaded mode and there are more than
99920 ** characteristics of the sorter in multi-threaded mode.
100700 ** mode, but not in multi-threaded mode.
101488 ** records to disk. If the sorter is running in multi-threaded mode,
101571 ** If using the single large allocation mode (pSorter->aMemory!=0), then
101903 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
101972 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
102320 ** in single-threaded mode. This is important, as the
114305 ** A. If an error is seen and not in PRAGMA writable_schema=ON mode,
120855 ** move as a result of the drop (can happen in auto-vacuum mode).
122173 assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */
123770 ** defensive mode, and the current sqlite3_prepare()
134318 ** Interpret the given string as a locking mode value.
134330 ** Interpret the given string as an auto-vacuum mode value.
134497 ** journal-mode name.
134902 ** the current default locking mode (which may be different to
134903 ** the locking-mode of the main database).
134910 ** of the PRAGMA command. In this case the locking-mode must be
134915 ** locking mode.
134949 ** current mode */
134958 /* If the "=MODE" part does not match any known journal mode,
134963 /* Do not allow journal-mode "OFF" in defensive since the database
135027 /* When setting the auto_vacuum mode to either "full" or
135369 ** in auto-commit mode. */
136428 ** mode. Change the OP_SetCookie opcode into a no-op. */
136541 ** 0x0001 Debugging mode. Do not actually perform any optimizations
137418 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
137421 ** meta[6] Incremental vacuum mode
139493 /* In this mode, write each query result to the key of the temporary
143918 pTab->tabFlags |= TF_Ephemeral; /* Legacy compatibility mode */
148606 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
148617 ** ONEPASS_OFF mode, serialize the array into a record and store it in
148618 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
151216 ** Return the ON CONFLICT resolution mode in effect for the virtual
159022 ** processing mode is used only for OR clause processing.
162763 ** index rather than the main table. In SQLITE_DEBUG mode, we want
163329 ** implementation is used in "slow mode" only - when the EXCLUDE clause
173852 /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
173861 /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
173870 /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
175876 ** mode: */
175922 ** not currently open in WAL mode.
176322 ** "cache=xxx" or "mode=xxx" query parameters.
176481 int mode;
176499 if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
176517 int mode = 0;
176521 mode = aMode[i].mode;
176525 if( mode==0 ){
176526 *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
176530 if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
176531 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
176536 flags = (flags & ~mask) | mode;
176934 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
176935 ** mode. Doing nothing at all also makes NORMAL the default.
177167 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
177800 ** "temp") which will receive the imposter. "onOff" turns imposter mode on
177804 ** Enable imposter mode only when the schema has already been parsed. Then
177806 ** the parsed schema. Then turn imposter mode back off again.
186721 unsigned char parenOnly; /* Only valid in paren mode */
186939 Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */
187710 ** Hash and comparison functions when the mode is FTS3_HASH_STRING
187728 ** Hash and comparison functions when the mode is FTS3_HASH_BINARY
195595 ** If the on-conflict mode is REPLACE, this means that the existing row
195597 ** if the on-conflict mode is other than REPLACE, then this method must
195615 ** rowid column. So if the conflict mode is REPLACE, then delete any
195618 ** Or, if the conflict mode is not REPLACE, insert the new record into
204192 ** In the first case, if the conflict-handling mode is REPLACE, then
204195 ** conflict-handling mode specified by the user.
208202 ** rollback mode while the *-oal file is being generated.
208217 ** detect the new *-wal file and read the database in wal mode. At
208340 ** * No constraint handling mode except for "OR ROLLBACK" is supported.
208518 ** An RBU update may not be applied to a database in WAL mode. Attempting
209222 /* Used in RBU vacuum mode only */
211681 p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database");
211894 ** the rbu object is in capture mode. Record the frame number of the frame
211926 ** file while the rbu handle is in capture mode. Record the page number
212009 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
212032 ** in WAL mode). So no other connection may be writing the db.
212815 ** to be a wal-mode db. But, this may have happened due to an earlier
212848 p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
212863 ** transaction is committed in rollback mode) currently stored on
213260 ** target database may not be in wal mode already.
213270 ** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
213272 ** are no-ops on target database files in RBU_STAGE_OAL mode. This is
213277 ** mode except RBU_STAGE_DONE (all work completed and checkpointed), it
213282 ** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
213650 ** one is found, this vfs will operate in pass-through mode. The lower
213958 ** in wal mode, even if the first page of the database file has
214748 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
219738 ** mode eType (either SQLITE_CHANGESET_OMIT or SQLITE_CHANGESET_REPLACE)..
222275 /* Bucket of terms object used by the integrity-check in offsets=0 mode. */
229512 u8 bContent; /* Set content-flag (detail=none mode) */
234973 ** This is the equivalent of fts5MergePrefixLists() for detail=none mode.
235586 ** mode only. */
237648 /* nBlob==0 in detail=none mode. */
244281 ** .mode line
244786 CODEC_STATIC void *opensslGetCtx(void *cipher, int mode, unsigned char *key, unsigned char *initVector){
244791 EVP_CipherInit_ex(tmpCtx, (EVP_CIPHER *)cipher, NULL, NULL, NULL, mode);
244793 EVP_CipherInit_ex(tmpCtx, NULL, NULL, key, initVector, mode);
245637 void* sqlite3Codec(void *ctx, void *data, Pgno pgno, int mode){
245650 switch(mode){