Lines Matching +defs:major +defs:mode
1164 ** format "X.Y.Z" where X is the major version number (always 3 for
1294 ** See the [threading mode] documentation for additional information.
1976 ** closes. Setting persistent WAL mode causes those files to persist after
1982 ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
1983 ** WAL mode. If the integer is -1, then it is overwritten with the current
1992 ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
1993 ** mode. If the integer is -1, then it is overwritten with the current
1994 ** zero-damage mode setting.
2123 ** the file descriptor is placed in "batch write mode", which
2141 ** the file descriptor out of batch write mode so that all subsequent
2150 ** ^This file control takes the file descriptor out of batch write mode
2185 ** in wal mode before the client starts to copy pages from the wal
2190 ** in wal mode after the client has finished copying pages from the wal
2758 ** [threading mode] to Single-thread. In other words, it disables
2759 ** all mutexing and puts SQLite into a mode where it can only be used
2762 ** it is not possible to change the [threading mode] from its default
2769 ** [threading mode] to Multi-thread. In other words, it disables
2777 ** it is not possible to set the Multi-thread [threading mode] and
2783 ** [threading mode] to Serialized. In other words, this option enables
2786 ** In this mode (which is the default when SQLite is compiled with
2793 ** it is not possible to set the Serialized [threading mode] and
3249 ** <dd> Usually, when a database in wal mode is closed or detached from a
3299 ** the database in WAL mode after the reset if it was in WAL mode before
4122 ** Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
4380 ** <dd>The database is opened in read-only mode. If the database does not
4404 ** if shared cache mode is enabled, but the "filename" is otherwise ignored.
4409 ** [threading mode].)^ This means that separate threads are allowed
4415 ** [threading mode].)^ This means the multiple threads can safely
4417 ** (Mutexes will block any actual concurrency, but in this mode
4498 ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw",
4503 ** third argument to sqlite3_open_v2(). ^If the mode option is set to
4507 ** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is
4510 ** the mode parameter that is less restrictive than that specified by
4568 ** <tr><td> file:data.db?mode=ro&cache=private <td>
4570 ** Regardless of whether or not shared-cache mode is enabled by
4575 ** <tr><td> file:data.db?mode=readonly <td>
4576 ** An error. "readonly" is not a valid option for the "mode" parameter.
4577 ** Use "ro" instead: "file:data.db?mode=ro".
4721 ** ^If X is the name of a rollback or WAL-mode journal file that is
4829 ** When the serialized [threading mode] is in use, it might be the
7189 ** KEYWORDS: {autocommit mode}
7193 ** zero if the given database connection is or is not in autocommit mode,
7194 ** respectively. ^Autocommit mode is on by default.
7195 ** ^Autocommit mode is disabled by a [BEGIN] statement.
7196 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
7451 ** ^(The cache sharing mode set by this interface effects all subsequent
7453 ** Existing database connections continue to use the sharing mode
7469 ** shared cache mode should be enabled per-database connection via
8333 ** the database is in auto-commit mode and there are no other open read-write
8736 ** when the [threading mode] is Serialized.
8737 ** ^If the [threading mode] is Single-thread or Multi-thread then this
9230 ** [shared cache mode] being enabled.
9255 ** wal file in wal mode databases, or the number of pages written to the
9256 ** database file in rollback mode databases. Any pages written as part of
9795 ** If running in [shared cache mode], the application must
9824 ** ^When running in shared-cache mode, a database operation may fail with
10021 ** is invoked each time data is committed to a database in wal mode.
10114 ** operation on database X of [database connection] D in mode M. Status
10116 ** ^(The M parameter must be a valid [checkpoint mode]:)^
10123 ** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode.
10124 ** ^On the other hand, passive mode might leave the checkpoint unfinished
10128 ** ^This mode blocks (it invokes the
10132 ** database file. ^This mode blocks new database writers while it is pending,
10136 ** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition
10141 ** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new
10145 ** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the
10152 ** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not
10156 ** because the database is not in WAL mode. ^Note that upon successful
10189 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
10211 ** KEYWORDS: {checkpoint mode}
10213 ** These constants define all valid values for the "checkpoint mode" passed
10263 ** ON CONFLICT mode specified.
10268 ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
10271 ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
10272 ** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
10315 ** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
10364 ** KEYWORDS: {conflict resolution mode}
10367 ** inform a [virtual table] implementation what the [ON CONFLICT] mode
10636 ** An instance of the snapshot object records the state of a [WAL mode]
10639 ** In [WAL mode], multiple [database connections] that are open on the
10674 ** <li> The database handle must not be in [autocommit mode].
10676 ** <li> Schema S of [database connection] D must be a [WAL mode] database.
10683 ** that a snapshot cannot be taken on a wal mode database with no wal
10689 ** database handle in autocommit mode but fails for some other reason,
10717 ** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there
10738 ** schema S is in [WAL mode]. A database connection might not know
10739 ** that the database file is in [WAL mode] if there has been no prior
10740 ** I/O on that database connection, or if the database entered [WAL mode]
10780 ** database is changed back to rollback mode or when the number of database
10812 ** transaction open on the database, or if the database is not a WAL mode
13453 ** checkpointing the database in WAL mode.
13567 ** WAL mode depends on atomic aligned 32-bit loads and stores in a few
16761 ** In shared cache mode, a single Schema object can be shared by multiple
16831 ** be stored in lookaside because in shared cache mode the schema information
16989 u8 dfltLockMode; /* Default locking-mode for attached dbs */
18057 u8 directMode; /* Direct rendering mode means take data directly
18059 u8 useSortingIdx; /* In direct mode, reference the sorting index rather
18926 TableLock *aTableLock; /* Required table locks for shared-cache mode */
19248 int sharedCacheEnabled; /* true if shared-cache mode enabled */
25974 ** apps that usually use SQLITE_CONFIG_MULTITHREAD mode.
27840 ** mode and specifically when the DMD "Dark Matter Detector" is enabled
28574 ** Set the StrAccum object to an error mode.
30731 /* This routine is never used in single-threaded mode */
33931 /* In test mode, increase the size of this structure a bit so that
33949 #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
34231 static int posixOpen(const char *zFile, int flags, int mode){
34232 return open(zFile, flags, mode);
34523 ** If the file creation mode "m" is 0 then set it to the default for
34526 ** make the file creation mode be exactly m ignoring the umask.
36028 ** This locking mode is appropriate for use on read-only databases
36033 ** corruption if this locking mode is used in situations where multiple
36075 ** Nevertheless, a dotlock is an appropriate locking mode for use if no
39752 ** Find the mode, uid and gid of file zFile.
39791 ** the default permissions. In 8_3_NAMES mode, leave *pMode set to zero.
39823 ** a '-' character. However in 8+3 filename mode, or if a corrupt
39838 ** its value as a filename and try to copy the mode, uid and gid from
40035 ** (probably because SQLite is configured to use 8+3 filename mode) and
41609 ** switching proxy locking mode off then it will need to fail if
41610 ** the journal mode is WAL mode.
42137 ** Compiling and using WAL mode requires several APIs that are only
42141 # error "WAL mode requires support from the Windows NT kernel, compile\
42296 ** mode or memory mapped files (e.g. these APIs are available in the Windows
42415 #define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
44451 /* The following blocks should probably assert in debug mode, but they
45563 ** This locking mode is appropriate for use on read-only databases
45568 ** corruption if this locking mode is used in situations where multiple
47098 int flags, /* Open mode flags */
48472 ** In rollback mode (which is always the case for memdb, as it does not
48473 ** support WAL mode) the truncate() method is only used to reduce
50345 ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
50408 PGroup grp; /* The global PGroup for mode (2) */
50911 ** private PGroup (mode-1). pcache1.separateCache is false if the single
50912 ** PGroup in pcache1.grp is used for all page caches (mode-2).
50914 ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
50921 ** * Otherwise use separate caches (mode-1)
52332 ** rollback (non-WAL) mode are met. Unless the pager is (or recently
52333 ** was) in exclusive-locking mode, a user-level read transaction is
52360 ** In rollback mode, a RESERVED or (if the transaction was opened with
52367 ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
52372 ** * If the connection is open in rollback-mode, a RESERVED or greater
52374 ** * If the connection is open in WAL-mode, a WAL write transaction
52385 ** first modified by the upper layer. In rollback mode the journal file
52413 ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
52488 ** connection is open in WAL mode. A WAL connection is always in one
52491 ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
52492 ** state. There are two exceptions: immediately after exclusive-mode has
52635 ** This mechanism means that when running in exclusive mode, a connection
52647 ** committed or rolled back when running in "journal_mode=PERSIST" mode.
52652 ** running in "journal_mode=truncate" mode.
52757 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
52763 ** that with synchronous=NORMAL in WAL mode, transaction commit is not synced
52777 u8 noLock; /* Do not lock (except in WAL mode) */
52785 ** significant mode change (such as changing the page_size, locking_mode,
53014 /* If the useJournal flag is clear, the journal-mode must be "OFF".
53015 ** And if the journal-mode is "OFF", the journal file must not be open.
53146 "Locking mode: locking_mode=%s\n"
53147 "Journal mode: journal_mode=%s\n"
53523 ** if the pager is not in no-sync mode, sync the journal file immediately
53577 ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
53614 ** if in full-sync mode), the zero is overwritten with the true number
53624 ** * When the pager is in no-sync mode. Corruption can follow a
53812 ** thing written to a journal file. If the pager is in full-sync mode, the
53852 /* If in full-sync mode, advance to the next disk sector before writing
53875 /* If the pager is in peristent-journal mode, then the physical
53912 ** if it is open and the pager is not in exclusive mode.
53949 ** This function is a no-op if the pager is in exclusive mode and not
53953 ** If the pager is not in exclusive-access mode, the database file is
53960 ** the OPEN state. Regardless of whether the pager is in exclusive-mode
54022 ** normal and exclusive-locking mode.
54053 ** all major API calls on the Pager will immediately return Pager.errCode.
54120 ** depends on whether or not the pager is running in exclusive mode and
54121 ** the current journal-mode (Pager.journalMode value), as follows:
54138 ** If the pager is running in exclusive mode, this method of finalizing
54140 ** DELETE and the pager is in exclusive mode, the method described under
54144 ** If running in non-exclusive rollback mode, the lock on the file is
54151 ** tries to unlock the database file if not in exclusive mode. If the
54254 ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
54261 ** mode if the database file on disk is larger than the database image.
54466 ** An exception to the above rule: If the database is in no-sync mode
54543 ** obscure. When running in synchronous mode, this can only happen
54956 ** working in no-sync mode. This means that the rest of the journal
55049 ** mode, then subsequent transactions performed by the connection will not
55414 ** in WAL mode. If the database is empty or if no *-wal file exists and
55670 ** single disk sector is atomic, then this mode provides
55678 ** The above is for a rollback-journal mode. For WAL mode, OFF continues
55683 ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
55686 ** and EXTRA for WAL mode.
55979 ** to WAL mode yet.
56322 ** Otherwise, the actions required depend on the journal-mode and the
56332 ** mode, then the journal file is synced before this field is updated.
56341 ** if( <full-sync mode> ) xSync(<journal file>);
56372 ** mode, then the journal file may at this point actually be larger
56410 ** full-synchronous mode, sync the journal first. This ensures that
56452 /* Unless the pager is in noSync mode, the journal file was just
56815 int memJM = 0; /* Memory journal mode */
57078 pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */
57322 ** 2) If the pager is running in exclusive-mode, and there are currently
57338 ** exclusive access mode. */
57383 ** Unless the pager is in locking_mode=exclusive mode, the lock is
57393 ** in exclusive-access mode the file descriptor will be kept open
57396 ** mode (and also for journal_mode=truncate on some systems).
57512 ** mode. Otherwise, the following function call is a no-op.
57879 ** If the journal file is already open (as it may be in exclusive mode),
57974 ** running in exclusive mode) or if the transaction does not require a
58022 ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
58027 ** WAL mode.
58410 ** operating in direct-mode, make page 1 writable. When not in
58411 ** direct mode, page 1 is always held in cache and hence the PagerGet()
58422 /* If running in direct mode, write the contents of page 1 to the file. */
58471 ** rollback. If the connection is in WAL mode, this call is a no-op.
58476 ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
58603 ** counter in 'indirect-mode'. If the optimization is compiled in but
58607 ** mode.
58611 ** in 'direct' mode. In this case the journal file will never be
58768 ** this transaction, the pager is running in exclusive-mode and is
58775 ** header. Since the pager is in exclusive mode, there is no need
58801 ** Otherwise, in rollback mode, this function performs two functions:
58813 ** In WAL mode, all cache-entries containing data modified within the
59365 ** Get/set the locking-mode for this pager. Parameter eMode must be one
59368 ** the locking-mode is set to the value specified.
59372 ** locking-mode.
59388 ** Set the journal-mode for this pager. Parameter eMode must be one of:
59405 ** The returned indicate the current (possibly updated) journal-mode.
59420 ** to WAL mode.
59436 /* Change the journal mode. */
59441 ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
59491 /* Return the new journal mode */
59496 ** Return the current journal mode.
59610 ** exclusive-locking mode when this function is called, take an EXCLUSIVE
59620 /* If the pager is already in exclusive-mode, the WAL module will use
59691 ** to switching from WAL to rollback mode.
59705 ** rollback mode. Open it now so this can happen.
59738 ** If pager pPager is a wal-mode database not in exclusive locking mode,
59844 ** the pager is in WAL mode and the WAL file currently contains one or more
59872 ** "journal_mode=WAL" mode.
60309 u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
61261 int bNoShm, /* True to run in heap-memory mode */
61769 ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
61817 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
61947 /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as
62006 ** ordinary, rollback-mode locking methods, this guarantees that the
62030 ** mode (!bPersist) */
62035 ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
63616 ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
63737 ** transition out of exclusive-mode is successful, return 1. This
63744 ** WAL is already in exclusive-locking mode - meaning that this
63760 ** happen if the connection is actually in exclusive mode (as no xShmLock
63762 ** upgrade to exclusive-mode following such an error.
64008 ** 64 4 Incremental vacuum mode
65327 ** by a connection in read-uncommitted mode is on the sqlite_schema
65454 ** database connetion. This is important in shared-cache mode. If the database
67312 ** and we are in shared cache mode, then the open will fail with an
67437 /* In debug mode, we mark all persistent databases as sharable
67495 ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
67844 ** and autovacuum mode can no longer be changed.
67967 ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
68104 ** in WAL mode. If the log is not already open, open it now. Then
69773 ** mode, the following events may invalidate an overflow page-list cache.
69776 ** * A commit in auto_vacuum="full" mode,
71431 ** freePage2() may zero the page contents if secure-delete mode is
72640 ** But not if we are in secure-delete mode. In secure-delete mode,
76018 int destMode; /* Destination journal mode */
76075 /* Do not allow backup if the destination database is in WAL mode
80148 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
80154 ** If SQLite is not threadsafe but does support shared-cache mode, then
80159 ** If SQLite is not threadsafe and does not support shared-cache mode, this
80474 ** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers
81042 ** its journal mode (among other things). This matrix determines which
81386 ** has made changes and is in autocommit mode, then commit those
86832 /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
89456 ** connection is currently not in autocommit mode, or if there are other
89716 ** in read/write mode.
90967 assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
93109 ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
93146 ** Change the journal mode of database P1 to P3. P3 must be one of the
93151 ** If changing into or out of WAL mode the procedure is more complicated.
93153 ** Write a string containing the final journal-mode to register P2.
93156 Btree *pBt; /* Btree to change journal mode of */
93158 int eNew; /* New journal mode */
93159 int eOld; /* The old journal mode */
93202 "cannot change %s wal mode from within a transaction",
93209 /* If leaving WAL mode, close the log file. If successful, the call
93219 /* Cannot transition directly from MEMORY to WAL. Use mode OFF
93225 ** mode, this transaction always uses a rollback journal.
94838 ** If the sorter is running in single-threaded mode, then all PMAs generated
94840 ** multi-threaded mode then up to (N+1) temporary files may be opened, where
94847 ** The sorter is running in multi-threaded mode if (a) the library was built
94857 ** sorter is running in single-threaded mode, then these PMAs are merged
94862 ** Or, if running in multi-threaded mode, then a background thread is
94878 ** If running in multi-threaded mode and there are more than
94891 ** characteristics of the sorter in multi-threaded mode.
95671 ** mode, but not in multi-threaded mode.
96457 ** records to disk. If the sorter is running in multi-threaded mode,
96540 ** If using the single large allocation mode (pSorter->aMemory!=0), then
96871 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
96940 /* eMode is always INCRINIT_NORMAL in single-threaded mode */
97288 ** in single-threaded mode. This is important, as the
114670 ** move as a result of the drop (can happen in auto-vacuum mode).
117513 ** defensive mode, and the current sqlite3_prepare()
127626 ** Interpret the given string as a locking mode value.
127638 ** Interpret the given string as an auto-vacuum mode value.
127805 ** journal-mode name.
128190 ** the current default locking mode (which may be different to
128191 ** the locking-mode of the main database).
128198 ** of the PRAGMA command. In this case the locking-mode must be
128203 ** locking mode.
128237 ** current mode */
128246 /* If the "=MODE" part does not match any known journal mode,
128251 /* Do not allow journal-mode "OFF" in defensive since the database
128315 /* When setting the auto_vacuum mode to either "full" or
128651 ** in auto-commit mode. */
129581 ** 0x0001 Debugging mode. Do not actually perform any optimizations
130411 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
130414 ** meta[6] Incremental vacuum mode
132233 /* In this mode, write each query result to the key of the temporary
140669 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
140680 ** ONEPASS_OFF mode, serialize the array into a record and store it in
140681 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
143228 ** Return the ON CONFLICT resolution mode in effect for the virtual
150464 ** processing mode is used only for OR clause processing.
153630 ** index rather than the main table. In SQLITE_DEBUG mode, we want
154140 ** implementation is used in "slow mode" only - when the EXCLUDE clause
158384 ** (In other words, the "major" token.)
158396 YYCODETYPE major; /* The major token value. This is the code
159252 yypParser->yystack[0].major = 0;
159424 yyTokenName[yytos->major]);
159427 yy_destructor(pParser, yytos->major, &yytos->minor);
159634 yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
159638 yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
159653 YYCODETYPE yyMajor, /* The major token to shift in */
159684 yytos->major = yyMajor;
160553 {yymsp[0].minor.yy60 = yymsp[0].major; /*A-overwrites-X*/}
160557 {sqlite3EndTransaction(pParse,yymsp[-1].major);}
160858 {yymsp[0].minor.yy60 = yymsp[0].major; /*A-overwrites-OP*/}
161238 {yymsp[0].minor.yy602=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
161335 {yymsp[-2].minor.yy602=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
161366 {yymsp[-1].minor.yy602 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy602,0);}
161385 {yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy602, 0);/*A-overwrites-B*/}
161389 yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy602, 0);
161575 { yymsp[0].minor.yy60 = yymsp[0].major; /*A-overwrites-X*/ }
161585 {yymsp[0].minor.yy50.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy50.b = 0;}
161856 {yylhsminor.yy113.eType = yymsp[-1].major; yylhsminor.yy113.pExpr = 0;}
161860 {yylhsminor.yy113.eType = yymsp[0].major; yylhsminor.yy113.pExpr = yymsp[-1].minor.yy602;}
161871 {yymsp[-1].minor.yy570 = yymsp[-1].major; /*A-overwrites-X*/}
161874 {yymsp[0].minor.yy570 = yymsp[0].major; /*A-overwrites-X*/}
161995 yymsp->major = (YYCODETYPE)yygoto;
162029 int yymajor, /* The major type of the error token */
162076 ** The second argument is the major token number. The third is
162084 ** <li> The major token number.
162094 int yymajor, /* The major token code number */
162222 yymx = yypParser->yytos->major;
162297 fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
164501 /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
164510 /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
164519 /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
166446 ** mode: */
166492 ** not currently open in WAL mode.
166877 ** "cache=xxx" or "mode=xxx" query parameters.
167036 int mode;
167054 if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
167072 int mode = 0;
167076 mode = aMode[i].mode;
167080 if( mode==0 ){
167081 *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
167085 if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
167086 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
167091 flags = (flags & ~mask) | mode;
167427 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
167428 ** mode. Doing nothing at all also makes NORMAL the default.
167651 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
168241 ** "temp") which will receive the imposter. "onOff" turns imposter mode on
168245 ** Enable imposter mode only when the schema has already been parsed. Then
168247 ** the parsed schema. Then turn imposter mode back off again.
177061 unsigned char parenOnly; /* Only valid in paren mode */
177279 Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */
178050 ** Hash and comparison functions when the mode is FTS3_HASH_STRING
178068 ** Hash and comparison functions when the mode is FTS3_HASH_BINARY
185916 ** If the on-conflict mode is REPLACE, this means that the existing row
185918 ** if the on-conflict mode is other than REPLACE, then this method must
185936 ** rowid column. So if the conflict mode is REPLACE, then delete any
185939 ** Or, if the conflict mode is not REPLACE, insert the new record into
194409 ** In the first case, if the conflict-handling mode is REPLACE, then
194412 ** conflict-handling mode specified by the user.
198410 ** rollback mode while the *-oal file is being generated.
198425 ** detect the new *-wal file and read the database in wal mode. At
198548 ** * No constraint handling mode except for "OR ROLLBACK" is supported.
198726 ** An RBU update may not be applied to a database in WAL mode. Attempting
199393 /* Used in RBU vacuum mode only */
201842 p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database");
202055 ** the rbu object is in capture mode. Record the frame number of the frame
202087 ** file while the rbu handle is in capture mode. Record the page number
202154 ** then reopens the database file (this time in vanilla, non-oal, WAL mode).
202177 ** in WAL mode). So no other connection may be writing the db.
202970 ** to be a wal-mode db. But, this may have happened due to an earlier
203003 p->zErrmsg = sqlite3_mprintf("cannot update wal mode database");
203018 ** transaction is committed in rollback mode) currently stored on
203360 ** target database may not be in wal mode already.
203370 ** RBU_STAGE_OAL mode are actually stored in heap memory. This is to
203372 ** are no-ops on target database files in RBU_STAGE_OAL mode. This is
203377 ** mode except RBU_STAGE_DONE (all work completed and checkpointed), it
203382 ** 3d. In RBU_STAGE_CAPTURE mode, all xRead() calls on the wal file, and
203750 ** one is found, this vfs will operate in pass-through mode. The lower
204072 ** in wal mode, even if the first page of the database file has
204815 ** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
209582 ** mode eType (either SQLITE_CHANGESET_OMIT or SQLITE_CHANGESET_REPLACE)..
212107 /* Bucket of terms object used by the integrity-check in offsets=0 mode. */
212946 ** (In other words, the "major" token.)
212958 fts5YYCODETYPE major; /* The major token value. This is the code
213155 fts5yypParser->fts5yystack[0].major = 0;
213261 fts5yyTokenName[fts5yytos->major]);
213264 fts5yy_destructor(pParser, fts5yytos->major, &fts5yytos->minor);
213471 fts5yyTracePrompt, zTag, fts5yyTokenName[fts5yypParser->fts5yytos->major],
213475 fts5yyTracePrompt, zTag, fts5yyTokenName[fts5yypParser->fts5yytos->major],
213490 fts5YYCODETYPE fts5yyMajor, /* The major token to shift in */
213521 fts5yytos->major = fts5yyMajor;
213790 fts5yymsp->major = (fts5YYCODETYPE)fts5yygoto;
213824 int fts5yymajor, /* The major type of the error token */
213869 ** The second argument is the major token number. The third is
213877 ** <li> The major token number.
213887 int fts5yymajor, /* The major token code number */
214015 fts5yymx = fts5yypParser->fts5yytos->major;
214090 fprintf(fts5yyTraceFILE,"%c%s", cDiv, fts5yyTokenName[i->major]);
219315 u8 bContent; /* Set content-flag (detail=none mode) */
224696 ** This is the equivalent of fts5MergePrefixLists() for detail=none mode.
225308 ** mode only. */
227336 /* nBlob==0 in detail=none mode. */
233951 ** .mode line