xref: /third_party/sqlite/src/sqlite3.c

212 ** optimizations, and hence set all compiler macros to 0
218 ** so the GCC_VERSION macro will be set to a correct non-zero value even
295 ** may be set prior to where they take effect, but after platform setup.
363 ** The SQLITE_CDECL macro is used to set the calling convention for
366 ** The SQLITE_APICALL macro is used to set the calling convention for
371 ** The SQLITE_CALLBACK macro is used to set the calling convention for
374 ** The SQLITE_SYSAPI macro is used to set the calling convention for
535 ** [SQLITE_THREADSAFE] compile-time option being set to 0.
747 ** Many SQLite functions return an integer result code from the set shown
1054 ** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
1196 ** implements [sqlite3_deserialize()] to set an upper bound on the size
1199 ** current limit.  Otherwise the limit is set to the larger of the value
1201 ** pointed to is set to the new limit.
1266 ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
1282 ** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
1313 ** of type "[sqlite3_vfs] **".  This opcodes will set *X
1365 ** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the
1455 ** the value that M is to be set to. Before returning, the 32-bit signed
1495 ** value of type (int). The integer value is set to 1 if the database is a wal
1497 ** currently has an SQL transaction open on the database. It is set to 0 if
1661 ** The flags argument to xOpen() includes all bits set in
1666 ** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.
1689 ** order and set up its I/O subsystem accordingly.
1700 ** will be set for TEMP databases and their journals, transient
1716 ** the xOpen method must set the sqlite3_file.pMethods to either
1765 ** or impossible to induce.  The set of system calls that can be overridden
1982 ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
1983 ** ^If the option is unknown or SQLite is unable to set the option
2118 ** it is not possible to set the Multi-thread [threading mode] and
2134 ** it is not possible to set the Serialized [threading mode] and
2310 ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
2312 ** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
2362 ** compile-time maximum mmap size set by the
2386 ** sorter to that integer.  The default minimum PMA Size is set by the
2432 ** compile-time option is not set, then the default maximum is 1073741824.
2621 ** option is used to set or clear (the default) a flag that governs this
2799 ** As well as being set automatically as rows are inserted into database
2800 ** tables, the value returned by this function may be set explicitly by
2847 ** set the value returned by calling sqlite3_last_insert_rowid(D) to R
2894 ** returns the value as set when the calling statement began executing.
3076 ** previously set handler.)^  ^Note that calling [sqlite3_busy_timeout()]
3078 ** busy handler and thus clear any previously set busy handler.
3753 ** <dd>The filename can be interpreted as a URI if this flag is set.</dd>)^
3834 ** set in the third argument to sqlite3_open_v2(), or if it has
3865 **     be used to access the database file on disk. ^If this option is set to
3871 **   <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw",
3872 **     "rwc", or "memory". Attempting to set it to any other value is
3875 **     access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
3876 **     third argument to sqlite3_open_v2(). ^If the mode option is set to
3879 **     been set. ^Value "rwc" is equivalent to setting both
3881 **     set to "memory" then a pure [in-memory database] that never reads
3886 **   <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
3900 **     which if set disables file locking in rollback journal modes.  This
3908 **     read-only media.  ^When immutable is set, SQLite assumes that the
3968 ** <b>Note to Windows Runtime users:</b>  The temporary directory must be set
4222 ** error code and message may or may not be set.
4263 ** [database connection] whose limit is to be set or queried.  The
4271 ** set at compile-time by a C preprocessor macro called
4280 ** simply invoke this interface with the third parameter set to -1.
4317 ** result set of a [SELECT] or the maximum number of columns in an index
4452 ** executed using [sqlite3_step()].  ^If there is an error, *ppStmt is set
4454 ** string or a comment) then *ppStmt is set to NULL.
4760 ** can be set using the sqlite3_bind_*() routines defined here.
4766 ** ^The second argument is the index of the SQL parameter to be set.
4976 ** ^Return the number of columns in the result set returned by the
4993 ** in the result set of a [SELECT] statement.  ^The sqlite3_column_name()
5073 ** returned result set of that [SELECT] is a table column (not an
5075 ** column is returned.)^  ^If the Nth column of the result set is an
5188 ** CAPI3REF: Number of columns in a result set
5192 ** current row of the result set of [prepared statement] P.
5272 ** should be returned. ^The leftmost column of the result set has the index 0.
5340 ** which is native to the platform, regardless of the text encoding set
5550 ** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]).  If the third
5556 ** its parameters.  The application should set this parameter to
5952 ** routine to set the subtype for the return value of an SQL function.
6002 ** allocation.)^  Within the xFinal callback, it is customary to set
6144 ** interfaces set the result of the application-defined function to be
6192 ** set the return value of the application-defined function to be
6530 ** It is required to set a temporary folder on Windows Runtime (WinRT).
6540 ** It is intended that this variable be set once
6560 ** <b>Note to Windows Runtime users:</b>  The temporary directory must be set
6597 ** It is intended that this variable be set once
6618 ** [sqlite3_win32_set_directory] interface is used to set the value associated
6634   unsigned long type, /* Identifier for directory being set or reset */
6635   void *zValue        /* New value for directory being set or reset */
6823 ** ^Any callback set by a previous call to sqlite3_commit_hook()
6827 ** ^Any callback set by a previous call to sqlite3_rollback_hook()
6941 ** ^Any callback set by a previous call to this function
7006 ** ^(The cache sharing mode set by this interface effects all subsequent
7099 ** the soft heap limit is set to the value of the hard heap limit.
7103 ** limit is set to N.  ^Invoking sqlite3_soft_heap_limit64(0) when the
7114 ** <li> The limit value is set to zero.
7196 ** parameters are set for the explicitly declared column. ^(If there is no
7198 ** for the [rowid] are set as follows:
7467 ** the corresponding bit is set within the colUsed mask if the column may be
7470 ** set. In other words, column iCol may be required if the expression
7517 ** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by
7568 ** Virtual table implementations are allowed to set the
7704 ** ^Virtual tables methods can set an error message by assigning a
7818 ** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided
7930 ** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning.
8038 ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
8041 ** with the makeDflt flag set.  If two different VFSes with the
8073 ** The SQLITE_MUTEX_NOOP implementation is a set of routines
8292 ** The set of static mutexes may change from one SQLite release to the
8439 ** These routines provide access to the set of SQL language keywords
8527 ** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead
8739 ** is an integer constant, taken from the set of
8741 ** determines the parameter to interrogate.  The set of
9044 ** The intent of the xInit() method is to set up global data structures
9083 ** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
9084 ** false will always have the "discard" flag set to true.
9089 ** ^(The xCachesize() method may be called at any time by SQLite to set the
9490 ** multiple times, it is invoked once with the set of void* context pointers
9493 ** related to the set of unblocked database connections.
9532 ** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
9579 ** the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0.
9752 ** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in
9755 ** NULL,then *pnCkpt is set to the total number of checkpointed frames in the
9760 ** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero.
9791 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
10017 ** can meet the ordering requirements of the query planner, it may set
10026 ** the xBestIndex method to set the "orderByConsumed" flag, regardless of
10061 ** specified above, then it must not set the "orderByConsumed" flag in the
10065 ** it wants, as long as the "orderByConsumed" flag is not set.  ^When the
10090 ** this constraint, it must set the corresponding
10133 ** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
10185 ** routines return SQLITE_OK and set *P to point to the first or next value
10187 ** right hand side of the IN constraint, then *P is set to NULL and these
10212 ** attempts to set *V to the value of the right-hand operand of
10214 ** right-hand operand is not known, then *V is set to a NULL pointer.
10216 ** and only if *V is set to a value.  ^The sqlite3_vtab_rhs_value(P,J,V)
10275 ** set to the total number of times that the X-th loop has run.</dd>
10278 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be set
10282 ** <dd>^The "double" variable pointed to by the V parameter will be set to the
10290 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10295 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10300 ** <dd>^The "int" variable pointed to by the V parameter will be set to the
10391 ** ^This function does not set the database handle error code or message
10738 ** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy
10779 ** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is
10783 ** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will
10785 ** connection closes.  If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then
10798 ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
11005 ** returned. If an error occurs, *ppSession is set to NULL and an SQLite
11065 **   This option is used to set, clear or query the flag that enables
11072 **   variable is set to 1 if the sqlite3session_changeset_size() API is
11112 **   <li> The session object "indirect" flag is set when the change is
11122 ** This function is used to set, clear or query the session object indirect
11125 ** is set. Passing a value less than zero does not modify the current value
11130 ** it is clear, or 1 if it is set.
11222 ** set *ppChangeset to point to a buffer containing the changeset
11224 ** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to
11244 ** PRIMARY KEY columns are set to NULL, the resulting changeset contains a
11360 **   <li> Has the same set of columns declared in the same order, and
11369 ** This function adds a set of changes to the session object that could be
11396 ** may be set to point to a buffer containing an English language error
11473 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
11474 ** is returned. Otherwise, if an error occurs, *pp is set to zero and an
11571 ** outputs are set through these pointers:
11573 ** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
11576 ** *pnCol is set to the number of columns in the table affected by the change; and
11578 ** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
11583 ** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
11613 ** If successful, *pabPK is set to point to an array of nCol entries, where
11614 ** nCol is the number of columns in the table. Elements of *pabPK are set to
11618 ** If argument pnCol is not NULL, then *pnCol is set to the number of columns
11646 ** [SQLITE_RANGE] is returned and *ppValue is set to NULL.
11655 ** is returned and *ppValue is set to NULL.
11677 ** [SQLITE_RANGE] is returned and *ppValue is set to NULL.
11683 ** a new value for the requested column, *ppValue is set to NULL and
11689 ** is returned and *ppValue is set to NULL.
11705 ** is set to NULL.
11709 ** [SQLITE_RANGE] is returned and *ppValue is set to NULL.
11717 ** is returned and *ppValue is set to NULL.
11864 ** (i.e. SQLITE_NOMEM) is returned and *pp is set to NULL.
11986 ** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK
11987 ** is returned and the output variables are set to the size of and a
12097 **   function is invoked with the second argument set to
12102 **   invoked with the second argument set to [SQLITE_CHANGESET_CONSTRAINT].
12147 ** may set (*ppRebase) to point to a "rebase" that may be used with the
12149 ** is set to the size of the buffer in bytes. It is the responsibility of the
12419 ** Allocate a new changeset rebaser object. If successful, set (*ppNew) to
12421 ** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew)
12448 ** is set to point to the new buffer containing the rebased changeset and
12452 ** are set to zero and an SQLite error code returned.
12516 ** into the buffer and set (*pnData) to the actual number of bytes copied
12518 ** should be set to zero to indicate this. Or, if an error occurs, an SQLite
12557 ** parameter set to a value less than or equal to zero. Other than this,
12665 **    to set and query the value of this configuration setting. The pointer
12669 **    pointed to by pArg is set to the final value of the streaming interface
12754 **   If parameter iCol is less than zero, set output variable *pnToken
12769 **   If parameter iCol is less than zero, set output variable *pnToken
12771 **   non-negative but less than the number of columns in the table, set
12784 **   current document. If successful, (*pz) is set to point to a buffer
12785 **   containing the text in utf-8 encoding, (*pn) is set to the size in bytes
12813 **   Usually, output parameter *piPhrase is set to the phrase number, *piCol
12833 **   with $p set to a phrase equivalent to the phrase iPhrase of the
12873 **   the auxiliary data is set to NULL and an error code returned. If the
12884 **   (set to NULL) before this function returns. In this case the xDelete,
12921 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
12930 **   APIs are used to iterate through the set of columns in the current row
12945 **   then this API always iterates through an empty set (all calls to
12946 **   xPhraseFirstColumn() set iCol to -1).
12958   int iVersion;                   /* Currently always set to 3 */
13021 **   should be set to point to the new tokenizer handle and SQLITE_OK
13043 **            determine the set of tokens to add to (or delete from) the
13070 **   normally be set to 0. The exception is if the tokenizer supports
13089 **   of "first place" within the document set, but not alternative forms
13230   int iVersion;                   /* Currently always set to 2 */
13323 **    * Terms in the result set of a SELECT statement
13543 ** to the next, so we have developed the following set of #if statements
13656 ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
13700 ** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG
13701 ** is set.  Thus NDEBUG becomes an opt-in rather than an opt-out
13819 ** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
14215 ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
14254 ** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
14475 ** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined
15085 ** is set high so that we don't have to allocate an unused page except
15537 ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
15618 ** The BTREE_BULKLOAD flag is set on index cursors when the index is going
15621 ** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or
15634 ** cursors it may be set to either (BTREE_WRCSR|BTREE_FORDELETE) or just
15635 ** (BTREE_WRCSR). If the BTREE_FORDELETE bit is set, then the cursor will
15697 ** an arbitrary key and no data.  These btrees have pKey,nKey set to the
16136 #define OP_SeekHit       125 /* synopsis: set P2<=seekHit<=P3              */
16399 ** The VdbeCoverage macros are used to set a coverage testing point
16428 ** sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE,...) to set a callback
16750 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
16828 ** These macros can be used to test, set, or clear bits in the
16839 ** The DB_SchemaLoaded flag is set after the database schema has been
16857 ** Lookaside malloc is a set of fixed-size buffers that can be used
16877 ** bDisable is greater than zero, sz is set to zero which effectively
16879 ** in a performance-critical path.  sz should be set by to szTrue whenever
17189                                           /*   result set is empty */
17327 ** a single object of this type is allocated. FuncDestructor.nRef is set to
17330 ** member of each of the new FuncDef objects is set to point to the allocated
17403 **     argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
17428 **     a single query.  The iArg is ignored.  The user-data is always set
17436 **     except that it does set the SQLITE_FUNC_CONSTANT flags.  iArg is
17437 **     ignored and the user-data for these functions is set to an
17457 **     FuncDef.flags variable is set to the value passed as the flags
17570 ** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the
17572 ** set.
17810 #define TF_HasStat1       0x00000010 /* nRowLogEst set from sqlite_stat1 */
17937 ** key is set to NULL.  SETDFLT means that the foreign key is set
18011 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
18015 ** The key comparison functions will set eqSeen to true if they ever
18263 ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
18268 ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
18297 ** If the EP_Reduced and EP_TokenOnly flags are set when
18298 ** an Expr object is truncated.  When EP_Reduced is set, then all
18302 ** allocated, regardless of whether or not EP_Reduced is set.
18320   /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
18332   /* If the EP_Reduced flag is set in the Expr.flags mask, then no
18397 #define EP_WinFunc   0x1000000 /* TK_FUNCTION with Expr.y.pWin set */
18406 /* The EP_Propagate mask is a set of properties that automatically propagate
18411 /* Macros can be used to test, set, or clear bits in the
18453 ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
18454 ** and an Expr struct with the EP_TokenOnly flag set.
18491 **    ENAME_NAME       (1) the AS of result set column
18497 **    ENAME_SPAN       Text of the original result set
18520         u16 iOrderByCol;      /* For ORDER BY, column number in result set */
18532 #define ENAME_NAME  0       /* The AS clause of a result set */
18533 #define ENAME_SPAN  1       /* Complete text of the result set expression */
18534 #define ENAME_TAB   2       /* "DB.TABLE.NAME" for the result set */
18580 ** In the colUsed field, the high-order bit (bit 63) is set if the table
18622   Bitmask colUsed;  /* Bit N set if column N used. Details above for N>62 */
18707 ** pEList corresponds to the result set of a SELECT and is NULL for
18726     ExprList *pEList;    /* Optional list of result-set columns */
18774 ** The pUpsertTarget field is only set if the ON CONFLICT clause includes
18820 ** for the result set.  The KeyInfo for addrOpenEphm[2] contains collating
18870 #define SF_FixedLimit    0x0004000 /* nSelectRow set by a constant LIMIT */
18899 **                     set is not empty.
18906 **                     opcode) for each row in the result set.
19025 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
19026 ** accessed (or set to 0 for triggers fired as a result of INSERT
19027 ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
19102 ** used to store the set of table-locks required by the statement being
19169   ** initialized as they will be set before being used.  The boundary is
19449 /* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
19548 ** For most test cases, CORRUPT_DB is set to false using a special
19710 **       of this object is stored in Expr.y.pWin with eFrmType set to
19786 ** to set a debugger breakpoint.
20922 ** a single bit set.
20925 ** argument match the type set by the previous sqlite3MemdebugSetType().
20929 ** argument match the type set by the previous sqlite3MemdebugSetType().
21133 ** If we compile with the SQLITE_TEST macro set, then the following block
22006 ** handle case conversions for the UTF character set since the tables
22088 ** Bit 0x20 is set if the mapped character requires translation to upper
22098 ** Bit 0x40 is set if the character is non-alphanumeric and can be used in an
22178 /* The minimum PMA size is set to this value multiplied by the database
22321 ** to read or write that page.  The pending byte page is set aside
22340 ** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
22575 ** set to NULL if the currently executing frame is the main program.
22618     double r;           /* Real value used when MEM_Real is set in flags */
22619     i64 i;              /* Integer value used when MEM_Int is set in flags */
22620     int nZero;          /* Extra zero bytes when MEM_Zero and MEM_Blob set */
22647 /* One or more of the following flags are set to indicate the
22653 **                             UPDATE no-change flag set
22664 **                             MEM_Term is set.  This flag is
22682 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
22684 ** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set.
22686 ** If the MEM_Str flag is set then Mem.z points at a string representation.
22689 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
22705 #define MEM_Cleared   0x0100   /* NULL set by OP_Null, not from data */
22744 ** is set.  It is "undefined" if all those bits are zero.
22788   sqlite3_value *argv[1]; /* Argument set */
22864   int rcApp;              /* errcode set by sqlite3_result_error_code() */
22867   u16 nResColumn;         /* Number of columns in one row of the result set */
22939 ** set of values on the right-hand side of an IN constraint.
23388     ** databases.  *pHighwater is set to zero.
23434     ** *pHighwater is set to zero.
23457     ** pagers the database handle is connected to. *pHighwater is always set
23486     ** have been satisfied.  The *pHighwater is always set to zero.
23581   char tzSet;         /* Timezone was set explicitly */
23609 ** the 2-digit day which is the last integer in the set.
23854 ** range of a julian day number, install it as such and set validJD.
23855 ** If the value is a valid unix timestamp, put it in p->s and set p->rawS.
24882 ** If we compile with the SQLITE_TEST macro set, then the following block
25495 **                                can be set manually, if desired.
25564 ** Include the malloc.h header file, if necessary.  Also set define macro
27258   /* Make sure the allocated memory does not assume that it is set to zero
27616 ** allocated by the system mutex implementation. Variable iType is usually set
27620 ** set to SQLITE_MUTEX_WARNONCONTENTION.
27790     /* If the xMutexAlloc method has not been set, then the user did not
28613 ** However, Visual Studio 2005 does not set _WIN32_WINNT by default, as
29109 ** Deprecated external interface.  It used to set an alarm callback
29218 ** words if the amount of heap used is close to the limit set by
29659 ** If the allocation fails, set the mallocFailed flag in
29740 ** resize fails, set the mallocFailed flag in the connection object.
29786 ** and set the mallocFailed flag in the database connection.
29854 ** has happened.  This routine will set db->mallocFailed, and also
29923 ** returned by sqlite3_errcode()) is set to SQLITE_NOMEM.
29946 ** This file contains code for a set of "printf"-like routines.  These
30617         ** set and we are not left justified */
30872 ** z and set the error byte offset in db.
31114 **        memory is used if not NULL. db->mallocFailed is set appropriately
31621       sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set");
31985       ** EP_Collate bit set and appear in treeview output as just "COLLATE" */
32102       ** trigger programs. In this case Expr.iTable is set to 1 for the
32104       ** is set to the column of the pseudo-table to read, or to -1 to
33312   ** Variable zOut is set to point at the output buffer, space obtained
33631 ** During testing, if the test harness has set a fault-sim callback using
33688 ** the column name if and only if the COLFLAG_HASTYPE flag is set.
33713 ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
33751 ** handle "db". The error code is set to "err_code".
33758 ** should be called with err_code set to SQLITE_OK and zFormat set
34428 ** If zNum represents an integer that will fit in 32-bits, then set
34545 ** for all bytes that have the 8th bit set and one byte with the 8th
34758 ** integer, then set *v to 0xffffffff.
35104 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
35110 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
35217 ** db->mallocFailed flag is set.
35245 ** VList are taken.  When that happens, nAlloc is set to zero as an
35727     /* 125 */ "SeekHit"          OpHelp("set P2<=seekHit<=P3"),
36228 ** and store the decoding there.  Or leave pFile->aJrnl set to NULL
36961 ** Only set the lastErrno if the error code is a real error and not
37477 ** If the file creation mode "m" is 0 then set it to the default for
37849 ** sets or clears a lock, that operation overrides any prior locks set
37851 ** that it overrides locks set by the same process using a different
37858 ** one is a hard or symbolic link to the other) then if you set
37877 ** locks to see if another thread has previously set a lock on that same
37896 ** structure.  The fcntl() system call is only invoked to set a
38029 ** set. It logs a message using sqlite3_log() containing the current value of
38058   /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
38114 ** a convenient place to set a breakpoint.
38330 ** file by this or any other process. If such a lock is held, set *pResOut
38331 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
38332 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
38384 ** value is set, then it is the number of milliseconds to wait before
38389 ** attempt to set the lock.
38417 ** Attempt to set a system-lock on the file pFile.  The lock is
38433 ** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
38731 ** set to a read lock, then the other part is simply unlocked.  This works
38733 ** remove the write lock on a region when a read lock is set.
39058 ** file by this or any other process. If such a lock is held, set *pResOut
39059 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
39060 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
39063 ** variation of CheckReservedLock(), *pResOut is set to true if any lock
39143   /* got it, set the type and return ok */
39242 ** file by this or any other process. If such a lock is held, set *pResOut
39243 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
39244 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
39349     /* got it, set the type and return ok */
39383   /* shared can just be set because we always have an exclusive */
39432 ** file by this or any other process. If such a lock is held, set *pResOut
39433 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
39434 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
39522   /* got it, set the type and return ok */
39551   /* shared can just be set because we always have an exclusive */
39638   int setLockFlag                /* True to set lock.  False to clear lock */
39675 ** file by this or any other process. If such a lock is held, set *pResOut
39676 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
39677 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
40115 ** is set before returning.
40208     /* pFile->lastErrno has been set by seekAndRead().
40244 ** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise,
40292 ** is set before returning.
40372       /* lastErrno set by seekAndWrite */
40375         "unixWrite, lastErrno set by seekAndWrite, fd[%d], offset[%lld], wrote[%d], amt[%d], lastErrno[%d]",
40445 ** to disk, not the inode.  We only set dataOnly if the file size is
40531 ** If successful, *pFd is set to the opened file descriptor and
40533 ** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
40547 ** *pFd set to a negative number.
40616   ** is set.  This is a one-time occurrence.  Many systems (examples: AIX)
40762       ** at offset (nSize-1), to set the size of the file correctly.
40813 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
40815 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
40979 ** pFd->deviceCharacteristics are set according to the file-system
41102 ** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default.
41220 ** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are
41388 ** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1.
41583   ** new (struct unixShm) object to the pShmNode has been set. All that is
41608 ** If an error occurs, an error code is returned and *pp is set to NULL.
41612 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
41618 ** address space (if it is not already), *pp is set to point to the mapped
41675         /* The requested memory region does not exist. If bExtend is set to
41676         ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
41980   /* Remove connection p from the set of connections associated
42031 ** Attempt to set the size of the memory mapping maintained by file
42167 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
42403 /* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
42901 ** the default permissions.  In 8_3_NAMES mode, leave *pMode set to zero.
42907   uid_t *pUid,                    /* OUT: uid to set on the file */
42908   gid_t *pGid                     /* OUT: gid to set on the file */
43028   **   (a) Exactly one of the READWRITE and READONLY flags must be set, and
43029   **   (b) if CREATE is set, then READWRITE must also be set, and
43030   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
43031   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
43045   /* Assert that the upper layer has set one of the "file-type" flags. */
43152     ** If openMode==0, then that means uid and gid are not set correctly
43649 ** The following variable, if set to a non-zero value, is interpreted as
43650 ** the number of seconds since 1970 and is used to set the result of
43746 ** as POSIX read & write locks over fixed set of locations (via fsctl),
43868 **       lock proxy files, only used when LOCKPROXYDIR is not set.
44307       /* I/O error: lastErrno set by seekAndRead */
44525 ** *pConchPath is set to NULL if a memory allocation error occurs.
44787 ** file by this or any other process. If such a lock is held, set *pResOut
44788 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
44789 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
45133 ** Make sure at least one set of Win32 APIs is available.
45245 ** This macro is used when a local variable is set to a value that is
45268 ** set we need.
45543 ** The following variable is (normally) set once and never changes
45552 ** can manually set this value to 1 to emulate Win98 behavior.
46990   unsigned long type, /* Identifier for directory being set or reset */
46991   const char *zValue  /* New value for directory being set or reset */
47034   unsigned long type, /* Identifier for directory being set or reset */
47035   const void *zValue  /* New value for directory being set or reset */
47050 ** the provided arguments.  The type argument must be 1 in order to set the
47051 ** data directory or 2 in order to set the temporary directory.  The zValue
47056   unsigned long type, /* Identifier for directory being set or reset */
47057   void *zValue        /* New value for directory being set or reset */
47208 ** may be used to include additional error codes in the set that should
47662 ** Otherwise, set pFile->lastErrno and return non-zero.
48568 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
48570 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
48963 ** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1.
49078   ** new (struct winShm) object to the pShmNode has been set. All that is
49117   /* Remove connection p from the set of connections associated
49272 ** If an error occurs, an error code is returned and *pp is set to NULL.
49276 ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
49282 ** address space (if it is not already), *pp is set to point to the mapped
49334       /* The requested memory region does not exist. If isWrite is set to
49335       ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
49579 ** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
49844   ** has been explicitly set by the application; otherwise, use the one
50137   **   (a) Exactly one of the READWRITE and READONLY flags must be set, and
50138   **   (b) if CREATE is set, then READWRITE must also be set, and
50139   **   (c) if EXCLUSIVE is set, then CREATE must also be set.
50140   **   (d) if DELETEONCLOSE is set, then CREATE must also be set.
50154   /* Assert that the upper layer has set one of the "file-type" flags. */
50168         "sqlite3_temp_directory variable should be set for WinRT");
50681     **       directory has been set.  Therefore, use it as the basis
50738     **       directory has been set.  Therefore, use it as the basis
50760     **       directory has been set.  Therefore, use it as the basis
51007 ** The following variable, if set to a non-zero value, is interpreted as
51008 ** the number of seconds since 1970 and is used to set the result of
51410   0,                           /* szOsFile (set when registered) */
51414   0,                           /* pAppData (set when registered) */
52222 ** may be set or cleared one at a time.
52224 ** Test operations are about 100 times more common that set operations.
52226 ** 5 and 500 set operations per Bitvec object, though the number of sets can
52291   u32 nSet;       /* Number of bits that are set - only valid for aHash
52321 ** Check to see if the i-th bit is set.  Return true or false.
52495 ** Then the following macros can be used to set, clear, or test
52520 ** The opcodes 1 through 4 perform set and clear operations are performed
52756   /* NEED_SYNC can be set independently of WRITEABLE.  This can happen,
52760   **    (3)  Page X reused, WRITEABLE is set again
52815       /* If there are now no dirty pages in the cache, set eCreate to 2.
52843     /* If pSynced is NULL and this page has a clear NEED_SYNC flag, set
52846     ** flag set sqlite3PcacheFetchStress() searches through all newer
52876     ** suggested cache size is set to N. */
53057     ** set incorrectly (pointing to other than the LRU page with NEED_SYNC
53648 ** the only element on the list with PgHdr1.isAnchor set to 1) forms the
53670 /* Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set
53711   ** flag (bPurgeable) and the pnPurgeable pointer are all set when the
54999 ** In an OOM situation, the RowSet.db->mallocFailed flag is set and this
55024 ** The mallocFailed flag of the database connection is set if a
55153 ** and leave *ppList set to NULL.
55273         /* Only sort the current set of entries if they need it */
55563 ** (7) At any time, if any subset, including the empty set and the total set,
55813 **    * The Pager.errCode variable is set to something other than SQLITE_OK.
55841 ** The Pager.eLock variable is almost always set to one of the
55852 ** VFS call is successful. This way, the Pager.eLock variable may be set
55854 ** at the system level, but it is never set to a more exclusive value.
55877 ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
55880 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
55885 ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
55920 ** set to 0. If a journal-header is written into the main journal while
55921 ** the savepoint is active, then iHdrOffset is set to the byte offset
55961 **   locks), this variable is always set to EXCLUSIVE_LOCK. Since such
55966 **   In some (obscure) circumstances, this variable may also be set to
55976 **   It is set to true when the change-counter field is updated, which
55978 **   It is cleared (set to false) whenever an exclusive lock is
56018 **   When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set,
56026 **   If the SPILLFLAG_NOSYNC bit is set, writing to the database from
56028 **   This flag is set by sqlite3PagerWrite() when the file-system sector-size
56043 **   Variable dbSize is set to the number of pages in the database file.
56047 **   dbSize is set based on the size of the database file, which may be
56068 **   the file on disk in pages. It is set to a copy of dbSize when the
56088 **   dbHintSize is set to a copy of the dbSize variable when a
56098 **   is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
56099 **   is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
56273 ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
56368   ** the change-counter field, so the changeCountDone flag is always set.
56397   /* If changeCountDone is set, a RESERVED lock or greater must be held
56573 **   * The bit corresponding to the page-number is not set in
56637 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
56639 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
56663 ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
56666 ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
56699 ** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is
56804 ** zSuper[0] is set to 0 and SQLITE_OK returned.
56884 ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
56889 ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
56990   **   * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
57056 ** If the header is read successfully, *pNRec is set to the number of
57057 ** page records following this header and *pDbSize is set to the size of the
57059 ** is set to the value read from the journal header. SQLITE_OK is returned
57126     /* Versions of SQLite prior to 3.5.8 set the page-size field of the
57128     ** variable is already set to the correct page size.
57273 ** Free all structures in the Pager.aSavepoint[] array and set both
57365     ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
57382   /* If Pager.errCode is set, the contents of the pager cache cannot be
57754 ** (if the corresponding pDone bit is set) then skip the playback.
57755 ** Make sure the pDone bit corresponding to the *pOffset page is set
58227 ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
58523 ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
58557       /* If the read is unsuccessful, set the dbFileVers[] to something
58838 ** if no error occurs, make sure Pager.journalMode is not set to
58904 ** corresponding bit is set in a bitvec structure (variable pDone in the
58925   /* Allocate a bitvec to use to store the set of pages rolled back */
59124   Pager *pPager,        /* The pager to set safety level for */
59254 ** then the pager object page size is set to *pPageSize.
59264 ** then *pPageSize is set to the old, retained page size before returning.
59340 ** Attempt to set the maximum database page count if mxPage is positive.
59359 ** The following set of routines are used to disable the simulated
59442 ** the lock. If the lock is obtained successfully, set the Pager.state
59562 ** If successful, set *ppPage to point to the new page reference
59563 ** and return SQLITE_OK. Otherwise, return an SQLite error code and set
59757 ** If the Pager.noSync flag is set, then this function is a no-op.
59823         ** Variable iNextHdrOffset is set to the offset at which this
59919 **   * The PGHDR_DONT_WRITE flag is set on the page.
59970     ** set (set by sqlite3PagerDontWrite()).
60040 ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
60124   /* The doNotSpill NOSYNC bit is set during times when doing a sync of
60130   ** regardless of whether or not a sync is required.  This is set during
60237 ** successfully, SQLITE_OK is returned and *ppPager set to point to
60238 ** the new pager object. If an error occurs, *ppPager is set to NULL
60294   ** leave both nPathname and zPathname set to 0.
60527   /* The following call to PagerSetPagesize() serves to set the value of
60604   /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
60640 ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
60650 ** If a hot-journal file is found to exist, *pExists is set to 1 and
60652 ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
60890         ** set to UNKNOWN_LOCK (see the comment above the #define for
60893         ** In order to get pager_unlock() to do this, set Pager.eState to
61042 ** savepoints are set. This means if the page is made writable at any
61047 ** an appropriate error code is returned and *ppPage is set to NULL.
61065   u8 noContent;                   /* True if PAGER_GET_NOCONTENT is set */
61118         /* Failure to set the bits in the InJournal bit-vectors is benign.
61121         ** to test the case where a malloc error occurs while trying to set
61515   ** page in the block above, set the need-sync flag for the page.
61551 ** one of the journals, the corresponding bit is set in the
61615   /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list
61705   /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
61706   ** starting at pg1, then it needs to be set for all of them. Because
61835   ** to this function. Otherwise, it is always set to zero.
61902 ** or pages with the Pager.noSync flag set.
62222   ** header with the nRec field set to 0. If such a journal is used as
62748   ** If the isCommit flag is set, there is no need to remember that
62760   ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
62799     ** "is journaled" bitvec flag has been set. This needs to be remedied by
62857 ** Get/set the locking-mode for this pager. Parameter eMode must be one
62860 ** the locking-mode is set to the value specified.
62889 ** The journalmode is set to the value specified if the change is allowed.
62892 **   *  An in-memory database can only have its journal_mode set to _OFF
62916   /* Do allow the journalmode of an in-memory database to be set to
63006 ** Get/set the size-limit used for persistent journal files.
63009 ** An attempt to set a limit smaller than -1 is a no-op.
63159 ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
63711 ** the nBackfillAttempted is set before any backfilling is done and the
63712 ** nBackfill is only set after all backfilling completes.  So if a checkpoint
63716 ** The aLock[] field is a set of bytes used for locking.  These bytes should
63844 ** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit
63847 ** If the LSB is set, then the checksums for each frame within the WAL
64361 ** slot in the hash table is set to N, it refers to frame number
64364 ** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the
64520     /* If the entry in aPgno[] is already set, then the previous writer
64764     ** checkpointers. Then set the values of read-mark slots 1 through N.
64831 ** *ppWal is set to point to a new WAL handle. If an error occurs,
65679 ** and *pChanged is set to 1.
65748 ** changed by this operation.  If pWal->hdr is unchanged, set *pChanged
65870 ** is set to true before returning if the caller should discard the
66038 ** wal-index header has changed, *pChanged is set to 1 (as an indication
66043 ** The caller must set the cnt parameter to the number of prior calls to
66064 ** this routine will always set pWal->readLock>0 on success.
66066 ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
66086   /* useWal may only be set for read/write connections */
66256   ** since it was read, set Wal.minFrame to the first frame in the wal
66264   ** checkpointer that set nBackfill was not working with a wal-index
66272   ** we can guarantee that the checkpointer that set nBackfill could not
66301 ** may be left set to a value larger than expected, if a wal frame
66376 ** transaction, then *pChanged is set to 1 before returning.  The
66400     ** has not yet set the pInfo->nBackfillAttempted variable to indicate
66448       ** with *pSnapshot and set *pChanged as appropriate for opening the
66497 ** Search the wal file for page pgno. If found, set *piRead to the frame that
66498 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
66799 ** This function is called just before writing a set of frames to the log
66978 ** Write a set of frames to the log. The caller must hold the write-lock
67003   /* If this frame set completes a transaction, then nTruncate>0.  If
67004   ** nTruncate==0 then this frame set does not complete the transaction. */
67086     ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that
67129   ** Padding and syncing only occur if this set of frames complete a
67161   /* If this frame set completes the first transaction in the WAL and
67162   ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
67253   ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */
67312     /* If no error occurred, set the output variables. */
67394   /* pWal->readLock is usually set, but might be -1 if there was a
67738 ** byte are used.  The integer consists of all bytes that have bit 8 set and
67758 **      4     Page number of the left child. Omitted if leaf flag is set.
67759 **     var    Number of bytes of data. Omitted if the zerodata flag is set.
67760 **     var    Number of bytes of key. Or the key itself if intkey flag is set.
67969 ** may not be modified once it is initially set as long as nRef>0.
67970 ** The pSchema field may be set once under BtShared.mutex and
67978 **   set to true.
68255 ** the database the corresponding bit is set. This allows integrity-check to
68306 ** set BtShared.db to the database handle associated with p and the
68372   ** should already be set correctly. */
68749 ** SQLITE_CORRUPT_BKPT. Or, if SQLITE_DEBUG is set, then the log message
68808   ** and has the read-uncommitted flag set, then no lock is required.
68878 ** read-uncommitted flag set, then it is OK for the other object to
68969 **       database (one with the BtShared.sharable flag set), and
68987   /* A connection with the read-uncommitted flag set will never try to
69074     ** set the BTS_PENDING flag to 0.
69216 ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
69218 ** set in BtShared.pHasContent. The contents of the bitvec are cleared
69241 ** page from the pager layer with the 'no-content' flag set. True otherwise.
69279 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
69281 ** set to point to a malloced buffer pCur->nKey bytes in size containing
69321 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
69364 ** cursors should have their BTCF_Multiple flag set.  The btreeCursor()
69366 ** the uncommon case when pExpect has the BTCF_Multiple flag set.
69639     ** If that byte is set, it means this page is also being used
70241 ** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned.
70832 ** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care
70894 ** may remain unchanged, or it may be set to an invalid value.
71341     /* If the B-Tree was successfully opened, set the pager-cache size to the
71575   Btree *p,              /* The btree to set the safety level on */
71604 ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
71697 **    newFlag==1       BTS_SECURE_DELETE set and BTS_OVERWRITE is cleared
71698 **    newFlag==2       BTS_SECURE_DELETE cleared and BTS_OVERWRITE is set
71703 ** With BTS_OVERWRITE set, deleted content is overwritten by zeros, but
71773 ** If the user has not set the safety-level for this database connection
71775 ** set to the value passed to this function as the second parameter,
71776 ** set it so.
71863     /* If the read version is set to 2, this database should be accessed
72207     ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
72304 ** pPage contains cells that point to overflow pages, set the pointer
72829     ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
72881   ** transaction and set the shared state to TRANS_READ.
72920 ** references.  Or if the writeOnly flag is set to 1, then only
73026     ** sure pPage1->aData is set correctly. */
73127 ** be used for reading.  If the BTREE_WRCSR bit is set, then the cursor
73144 ** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR
73145 ** is set.  If FORDELETE is set, that is a hint to the implementation that
73209   ** cursors *must* have the BTCF_Multiple flag set. */
73453 ** list, *pPgnoNext is set to zero.
73456 ** to page number pOvfl was obtained, then *ppPage is set to point to that
73460 ** *ppPage is set to zero.
73936 ** pCur->idx is set to the cell index that contains the pointer
73938 ** right-most child page then pCur->idx is set to one more than
73969 ** If the b-tree structure is empty, the cursor state is set to
73971 ** the cursor is set to point to the first cell located on the root
73972 ** (or virtual root) page and the cursor state is set to CURSOR_VALID.
73977 ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
73979 ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
74114 ** or set *pRes to 1 if the table is empty.
74136 ** or set *pRes to 1 if the table is empty.
74431 ** The pIdxKey->eqSeen field is set to 1 if there
74866 ** an error.  *ppPage is set to NULL in the event of an error.
75125     ** pager layer with the 'no-content' flag set. This prevents the pager
75130     ** not set the no-content flag. This causes the pager to load and journal
75511   /* At this point variables should be set as follows:
75917 ** responsibility of the caller to set it correctly.
75974   /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
76131 ** responsibility of the caller to set it correctly.
76309     ** operations fails, the return code is set, but the contents
76496 ** If aOvflSpace is set to a null pointer, this function returns
77009   ** of the right-most new sibling page is set to the value that was
77018   ** map entries associated with divider cells are set by the insertCell()
77248     ** all pointer map pages are set correctly. This is helpful while
77286 ** If successful, *ppChild is set to contain a reference to the child
77289 ** an error code is returned and *ppChild is set to 0.
77664       ** Which can only happen if the SQLITE_NoSchemaError flag was set when
77666       ** set the flag, load the schema, and then unset the flag.  */
77702     /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
77740     /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
77882   ** set the cursor state to "invalid". This makes common insert operations
77902     ** Also, set the cursor state to invalid. This stops saveCursorPosition()
78044 ** But if that bit is set, then the cursor is left in a state such that
78534 ** is necessary for AUTOVACUUM to work right.  *piMoved is set to the
78536 ** the move.  If no page gets moved, *piMoved is set to 0.
78745     ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
78821 ** corresponds to page iPg is already set.
79671   ** WAL connection, even if the version fields are currently set to 2.
79779   /* These two variables are set by every call to backup_step(). They are
79855 ** Attempt to set the page size of the destination to match the page size
80025   ** page. For each iteration, variable iOff is set to the byte offset
80134     ** try to set its page size to the same as the source database. This
80508   /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
80527   ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
80570 ** In other words, return true if X has at most one bit set.
80582   /* If MEM_Dyn is set then Mem.xDel!=0.
80587   /* MEM_Dyn may only be set if Mem.szMalloc==0.  In this way we
80600     /* If MEM_Null is set, then either the value is a pure NULL (the usual
80601     ** case) or it is a pointer set using sqlite3_bind_pointer() or
80603     ** set.
80612       /* No other bits set */
80791   /* If the bPreserve flag is set to true, then the memory cell must already
80955 ** Add MEM_Str to the set of representations for the given Mem.  This
81404 ** Delete any previous value and set the value stored in *pMem to NULL.
81427 ** Delete any previous value and set the value to be a BLOB of length
81458 ** to a value change.  So invoke the destructor, then set the value to
81468 ** Delete any previous value and set the value stored in *pMem to val,
81504 ** Delete any previous value and set the value stored in *pMem to val,
81528 ** Delete any previous value and set the value of pMem to be an
81686   Mem *pMem,          /* Memory cell to set to string value */
81701   /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
81988 **   * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
81989 **   * the SQLITE_FUNC_NEEDCOLL function flag is not set,
81992 ** error occurs, output parameter (*ppVal) is set to point to a value
82000 ** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
82255 ** cannot be converted to a value, then *ppVal is set to NULL.
82349 ** this function returns, output parameter *pnExtract is set to the
82355 ** is allocated (and *ppRec set to point to it) before returning.
82400 ** If successful, set *ppVal to point to a new value object and return
82402 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
82487   sqlite3_value *v,     /* Value to be set */
82736 /* This routine is just a convenient place to set a breakpoint that will
83052   ** co-routine has its own independent set of registers, because co-routines
83270       /* hasCreateIndex may also be set for some DELETE statements that use
83288   ** through all opcodes and hasAbort may be set incorrectly. Return
83570 ** Before returning, *pnOp is set to the number of entries in the returned
83571 ** array. Also, *pnMaxArg is set to the larger of its current value and
84399 ** The prepared statements need to know in advance the complete set of
84422 ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
84513 ** be initialized are set.  The Mem structure is organized so that
84544 ** set to MEM_Undefined.
84562       ** being set to NULL after releasing any dynamic resources.
84779   Mem *pMem = &p->aMem[1];             /* First Mem of result set */
84803     /* The first 8 memory cells are used for the result set.  So we will
85238 ** statement. This is now set at compile time, rather than during
85479     ** flag is set this is not required.
85652 ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY
85764     /* If the auto-commit flag is set and this is the only active writer
85873   /* If the auto-commit flag is set to true, then any locks that were held
85968   ** if the VDBE has just been set to run but has not actually executed any
86189 ** cursor, set the cursor to point to a NULL row.
86477                ** UPDATE no-change flag set */
86569 ** stack space). If the former, then *ppFree is set to a pointer that should
86571 ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
86620     /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
86630     /* In a corrupt record entry, the last pMem might have been set up using
86797   u8 *prcErr                      /* If an OOM occurs, set to SQLITE_NOMEM */
87058 ** If database corruption is discovered, set pPKey2->errCode to
87060 ** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the
87061 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
87652 ** prepared statements.  The flag is set to 1 for an immediate expiration
87653 ** and set to 2 for an advisory expiration.
88235 ** result as a string or blob.  Appropriate errors are set if the string/blob
88831 ** Set the iterator value pVal to point to the first value in the set.
88839 ** Set the iterator value pVal to point to the next value in the set.
88936 ** deleted by calling the delete function specified when it was set.
89004 ** Return the number of columns in the result set for the statement pStmt.
89086 ** code of statement pStmt set to SQLITE_NOMEM.
89102   ** sqlite3_column_XXX API, then set the return code of the statement to
89117 ** in the result set.
89243 ** Return the name of the Nth column of the result set returned by SQL
89267 ** of the result set of SQL statement pStmt.
89362   /* If the bit corresponding to this variable in Vdbe.expmask is set, then
90323 ** field of the sqlite3 structure is set in order to simulate an interrupt.
90391 /* This routine provides a convenient place to set a breakpoint during
90582 ** floating point value of rValue.  Return true and set *piValue to the
90747 ** But it does set pMem->u.r and pMem->u.i appropriately.
90903 ** checks that the sqlite3.nTransaction variable is correctly set to
91244 ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
91251   /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
91323 ** integer or else an assert() is raised.  P3 should be set to 1 when
91324 ** this opcode is used in combination with OP_BeginSubrtn, and set to 0
91495       ** instruction is set to OE_Ignore, then the sub-program is throwing
91655 ** is the same as the P2 operand to this opcode and that has P3 set to 1.
91677 ** set to NULL.
91679 ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
91680 ** NULL values will not compare equal even if SQLITE_NULLEQ is set on
91819 ** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the
92193 ** max() aggregate will set to 1 if the current row is not the minimum or
92197 ** to retrieve the collation sequence set by this opcode is not available
92413 ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
92435 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
92524       /* If SQLITE_NULLEQ is set (which will only happen if the operator is
92541       ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
92654 ** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5.
92674 ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
93093 ** If it is, then set register P3 to NULL and jump immediately to P2.
93163 ** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed
93166 ** OPFLAG_TYPEOFARG bit is set then the result will only be used by the
93253       ** the complete header, then set it to zero, forcing the header to be
93976 ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
93977 ** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE).
93978 ** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK).
94131       ** too. If it is a ROLLBACK TO, then set the number of deferred
94239 ** true (this flag is set if the Vdbe may modify more than one row and may
94353     ** reprepared, changeCntOn will be set again. */
94402 ** schema version is set to P3-P5.  The "PRAGMA schema_version=N" statement
94403 ** has P5 set to 1, so that the internal schema version will be different
94493 ** OPFLAG_P2ISREG bit is set in P5 - see below).
94585     ** that opcode will always set the p2 value to 2 or more or else fail.
94873 ** by the cursor.  The high-order bit is set if any column after
95008     /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
95353 ** Synopsis: set P2<=seekHit<=P3
95393 ** If cursor P1 is not open or if P1 is set to a NULL row using the
95869 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
95870 ** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
95874 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
95876 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
95879 ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
95989 ** with the OPFLAG_PREFORMAT flag set to complete the insert operation.
96011 ** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
96019 ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
96025 ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
96036 ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
96038 ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
96040 ** be set to by the update.
96064     ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
96071   /* If the update-hook or pre-update-hook will be invoked, set zDb to
96072   ** the name of the db to pass as to it. Also set local pTab to a copy
96074   ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set
96106   /* Only flags that can be set are SAVEPOISTION and AUXDELETE */
96650 ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
96653 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
96657 ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
96659 ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
97406 ** are inserted in distinct phases, which each set contains no duplicates.
97407 ** Each set is identified by a unique P4 value. The first set
97408 ** must have P4==0, the final set must have P4==-1, and for all other sets
97414 ** never be tested for, and (c) when a value that is part of set X is
97416 ** previously inserted as part of set X (only if it was previously
97417 ** inserted as part of some other set).
97481   ** disabled for backwards compatibility (p5 is set if this sub-program
97482   ** is really a trigger, not a foreign key action, and the flag set
97508     /* SubProgram.nMem is set to the number of memory cells used by the
97729 ** and r[P2] is set to be the value of the LIMIT, r[P1].
97732 ** and r[P2] is set to -1.
97734 ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
98287 ** Also, whether or not P4 is set, check that this is not being called from
98289 ** code will be set to SQLITE_LOCKED.
98422 ** the filtered result set is empty.
98435 ** A jump is made to P2 if the result set after filtering would be empty.
98545 ** Advance virtual table P1 to the next row in its result set and
98547 ** the end of its result set, then fall through to the next instruction.
98640 ** P1 is a boolean flag. If it is set to true and the xUpdate call
98642 ** is set to the value of the rowid for the row just inserted.
98719 ** Try to set the maximum page count for database P1 to the value in P3.
98753 ** argument was constant then bit 0 of P1 is set. This is used to determine
98772 ** argument was constant then bit 0 of P1 is set. This is used to determine
99066 ** except if bit ii of P3 set, then do not release register P1+ii.
99070 ** that if the content of the released register was set using OP_SCopy,
99074 ** If P5 is set, then all released registers have their type set
99078 ** P5 ought to be set on every call to this opcode.
99303 ** be set to point to a buffer containing an error message. It is the
99738 ** database handle error code and message set. If this happens, then all
99849 ** a threshold, when Rewind() is called the set of records is sorted using
99855 ** threshold, then the set of records currently in memory are sorted and
99863 ** page-cache of the main database. Specifically, the threshold is set to
99877 ** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater
99897 ** Parameter T is set to half the value of the memory threshold used
99903 ** disk are merged together. Then T bytes of data from the second set, and
99988 ** aTree element is set to the index of it.
100021 ** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree.
100023 ** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Banana<Durian),
100043 ** other way. VdbeSorter.nTask is set to the number of worker threads allowed
100053 ** Before a background thread is launched, variable bDone is set to 0. Then,
100090 **   this variable is updated so as to be set to the size on disk of the
100243 ** argument. All structure fields are set to zero before returning.
100255 ** If successful, set *ppOut to point to a buffer containing the data
100381 ** Attempt to memory map file pFile. If successful, set *pp to point to the
100384 ** mmap), return SQLITE_OK and set *pp to NULL.
100555 ** version of key2 and *pbKey2Cached set to true before returning.
100557 ** If an OOM error is encountered, (pTask->pUnpacked->error_rc) is set
101078 ** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK.
101079 ** Otherwise, set *ppFd to 0 and return an SQLite error code.
101281 ** Before returning, set *piEof to the offset immediately following the
101424       /* If pReadr1 contained the smaller value, set aTree[i] to its index.
101425       ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this
101426       ** case there is no cache of pReadr2 in pTask->pUnpacked, so set
101430       ** set aTree[i] to its index and update pReadr1. If vdbeSorterCompare()
101432       ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent
101880 ** set the PmaReader objects up to read from it. In this case all that is
101939 ** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders
101941 ** loaded into the buffers belonging to pReadr and it is set to point to
101944 ** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed
101948 ** pReadr is populated. However, pReadr itself is not set up to point
101958 ** Finally, if argument eMode is set to INCRINIT_ROOT, it may be assumed
101962 ** the current PmaReader set to point to the first key in its range.
102074 ** PMAs from pTask->file. If no error occurs, set *ppOut to point to
102075 ** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut
102078 ** When this function is called, *piOffset is set to the offset of the
102080 ** set to the offset immediately following the last byte of the last
102192 ** If successful, SQLITE_OK is returned and *ppOut set to point to the
102391   /* Assuming no errors have occurred, set up a merger structure to
102501 ** Otherwise, set *pRes to a negative, zero or positive value if the
103532 ** callback is set, then the Select->pWinDefn list is traversed.
103657 ** Walker.xSelectCallback is set to do something useful for every
103726 ** result set in pEList.
103745   ExprList *pEList,      /* A result set */
103746   int iCol,              /* A column in the result set.  0..pEList->nExpr-1 */
103747   Expr *pExpr,           /* Transform this into an alias to the result set */
103750   Expr *pOrig;           /* The iCol-th column of the result set */
103859 ** iColumn.  Append this new expression term to the FULL JOIN Match set
103861 ** set.
103882 ** that name in the set of source tables in pSrcList and make the pExpr
104226     ** might refer to an result-set alias.  This happens, for example, when
104232     ** forms the result set entry ("a+b" in the example) and return immediately.
104233     ** Note that the expression in the result set should have already been
104236     ** The ability to use an output result-set column in the WHERE, GROUP BY,
104393   ** bit 0 to be set.  Column 1 sets bit 1.  And so forth.  Bit 63 is
104394   ** set if the 63rd or any subsequent column is used.
104398   ** if the mask contains extra set bits.  However, it is important to
104402   ** If a generated column is referenced, set bits for every column
104467 ** Report an error that an expression is not valid for some set of
104978 ** pEList is a list of expressions which are really the result set of the
105019 ** ORDER BY term is not an integer index into the result set.  That
105022 ** Attempt to match pE against result set columns in the left-most
105037   ExprList *pEList;  /* The columns of the result set */
105062   ** in the result set.  Return an 1-based index of the matching
105063   ** result-set entry.
105099 ** are matched against result set expressions of compound SELECT
105202             "column in the result set", i+1);
105212 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
105213 ** field) then convert that term into a copy of the corresponding result set
105286 ** number of columns in the result set of the SELECT) then the expression
105287 ** in the resolution is a copy of the I-th result-set expression.  If
105289 ** a result-set expression, then the term resolves to a copy of the
105290 ** result-set expression.  Otherwise, the expression is resolved in
105307   int nResult;                   /* Number of terms in the result set */
105320         ** a copy of the iCol-th result-set column.  The subsequent call to
105322         ** copy of the iCol-th result-set expression. */
105328       /* The ORDER BY term is an integer constant.  Again, set the column
105330       ** order-by term to a copy of the result-set expression */
105347         ** to an identical expression in the result set, remove all Window
105399     assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */
105413     /* If the SF_Converted flags is set, then this Select object was
105455     ** resolve the result-set expression list.
105461     /* Resolve names in the result set. */
105465     /* If there are no aggregate functions in the result-set, and no GROUP BY
105481     ** aliases in the result set.
105531     ** set expressions by the call to resolveOrderGroupBy() below.  */
105602 ** table columns and result-set columns.  At the same time, do error
105603 ** checking on function usage and set a flag if any aggregate functions
105625 ** To resolve result-set references, look for expression nodes of the
105627 ** size of an AS clause in the result-set of a SELECT.  The Z expression
105628 ** is replaced by a copy of the left-hand side of the result-set expression.
105641 ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
105643 ** property on the expression is set.
105772 ** nodes of the expression is set to -1 and the Expr.iColumn value is
105773 ** set to the column number.  In case (4), TK_COLUMN nodes cause an error.
105775 ** Any errors cause an error message to be set in pParse.
105799       /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
106179 ** However, if the OP_Commuted flag is set, then the order of the operands
106265 ** just the expression for the i-th term of the result set, and may
106383 ** is generated. In this case (*pRegFree) may be set to the number of
106386 ** Before returning, output parameter (*ppExpr) is set to point to the
106540 ** to by pnHeight, the second parameter, then set *pnHeight to that
106643 ** then the EP_DblQuoted flag is set on the expression node.
106648 ** into u.iValue and the EP_IntValue flag is set.  No extra storage
106754 ** Expr node.  Or, if an OOM error occurs, set pParse->db->mallocFailed,
107204 ** If the EXPRDUP_REDUCE flag is set, then the return value includes
107225 ** if any. Before returning, *pzBuffer is set to the first byte past the
107252     ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
107335 ** and the db->mallocFailed flag set.
107406 ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
107691   ** wildcards ("*") in the result set of the SELECT must be expanded before
107772 ** is set.
107807 ** is set.
107881 ** always "fails".  By "fail" in this case, we mean set
107979 ** In all cases, the callbacks set Walker.eCode=0 and abort if the expression
108226 ** If isInit is true, set EP_FromDDL on every TK_FUNCTION node.
108266   ** integer, then the EP_IntValue flag will have already been set */
108436 ** it contains any NULL entries.  Cause the register at regHasNull to be set
108438 ** to be set to NULL if iCur contains one or more NULL values.
108475 ** be used either to test for membership in the RHS set or to iterate through
108476 ** all members of the RHS set, skipping duplicates.
108479 ** and the *piTab parameter is set to the index of that cursor.
108501 ** will be set on pX and the pX->y.sub fields will be set to show where
108507 ** membership test.  When the IN_INDEX_LOOP bit is set, the IN index will
108511 ** through the set members) then the b-tree must not contain duplicates.
108517 ** for fast set membership tests) then an epheremal table must
108521 ** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and
108575   ** set prRhsHasNull to 0 before continuing.  */
109695 ** is not a temporary or if the expression is a vector set *piFreeable
109725 ** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5)
110326         ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG
110471       ** trigger programs. In this case Expr.iTable is set to 1 for the
110473       ** is set to the column of the pseudo-table to read, or to -1 to
110477       ** parameter is set to 0 for an old.rowid reference, or to (i+1)
110480       ** set to (n+1), where n is the number of columns in each pseudo-table.
110482       ** is set to (n+2+i), where n and i are as defined previously. For
110759 ** a temporary, then set *pReg to zero.
110855 ** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0
111656 ** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
112574         "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
112691     ** literal NULL, then set pDflt to 0. This simplifies checking
113526     ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to
115169   /* StatAccum.nMaxEqZero is set to the maximum number of leading 0
115269   ** p->nMaxEqZero or greater set to zero. */
116171     /* Index.aiRowEst may already be set here if there are duplicate
116238       ** sample columns except the last. The last is always set to 1, as
116265       ** the nEq values for column iCol for the same set (adding the value
116616 ** If the db->init.reopenMemdb flags is set, then instead of attaching a
116964     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
116965     ** statement only). For DETACH, set it to false (expire all existing
117110 ** The following set of routines walk through the parse tree and assign
117662     ** set for each database that is used.  Generate code to start a
117773     ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set
118449 ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
118454 ** Then pName1 is set to "yyy" and pName2 is "".
118819     /* If the file format and encoding in the database have not been set,
118820     ** set them now.
118908 ** statement with a result set that is the argument of the RETURNING clause.
119005   ** set the Column.eType field rather than storing the typename after
119298 ** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
119509 ** set back to prior value.  But schema changes are infrequent
120086 ** the new table will match the result set of the SELECT.
120194       ** actually be used if PRAGMA writable_schema=ON is set. */
120523   Table *pSelTab;   /* A fake table from which we get the result set */
120575   ** "*" elements in the results set of the view and will assign cursors
121048 ** The foreign key is set for IMMEDIATE processing.  A subsequent call
121434     ** is a temp table. If so, set the database to 1. Do not do this
122107 ** returned. *pIdx is set to the index of the new array entry in this case.
122109 ** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains
122735 ** is set if the setStatement parameter is true.  A checkpoint should
122736 ** be set for operations that might fail (due to a constraint) part of
122740 ** necessary to undo a write and the checkpoint should not be set.
122767 ** Technically, we only need to set the mayAbort flag if the
122768 ** isMultiWrite flag was previously set.  There is a time dependency
123582   ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in
123833 ** set of rows in the view that are to be added to the ephemeral table.
124149   ** API function sqlite3_count_changes) to be set incorrectly.
124186       /* For a rowid table, initialize the RowSet to an empty set */
124633 ** will be set to zero which is an empty label that is ignored by
125455       ** For a case-insensitive search, set variable cx to be the same as
126234   ** flag is set.  See the sqlite3_enable_load_extension() API.
126637 ** of the built-in functions above are part of the global function set.
126682 ** then set aWc[0] through aWc[2] to the wildcard characters and the
126688 ** That one byte is stored in aWc[3].  aWc[3] is set to zero if there is
126691 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
126693 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
127156 ** with the database handle. The counter is set to zero each time a
127239 **   sqlite3FkOldmask()  - Query for the set of required old.* columns.
127274 ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
127275 ** is set to point to the unique index.
127278 ** is not a composite foreign key), output variable *paiCol is set to NULL.
127279 ** Otherwise, it is set to point to an allocated array of size N, where
127305 ** pParse->db->mallocFailed flag is set.
127326   ** and *paiCol set to zero and return early.
127532       ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any
127891     ** If the SQLITE_DeferFKs flag is set, then this is not required, as
127916 ** is set to -1). If the rowid column is modified by the UPDATE statement
127943 ** is set to -1). If the rowid column is modified by the UPDATE statement
128055     ** schema items cannot be located, set an error in pParse and return
128183         ** So do not set the "may-abort" flag in this case.
128186         ** may-abort flag will eventually be set on this statement anyway
128195         ** might be set incorrectly if any OP_FkCounter related scans are
128246 ** entry in the aChange[] array is set to -1. If the column is modified,
128247 ** the value is 0 or greater. Parameter chngRowid is set to true if the
128750 ** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the
128752 ** then just set the P4 operand of the previous opcode (which should  be
128773 ** register set as the OP_MakeRecord.  If iReg>0 then register iReg is
128920       ** then set the P3 operand to indicate that generated columns should
129595   ** key, the set the ipkColumn variable to the integer primary key
129954       ** parent table in a foreign key constraint. It is safe to set the
129998     ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the
130688         ** recursive-triggers flag is set, call GenerateRowDelete() to
130693         ** flag is not set, but the table has one or more indexes, call
131163   int useSeekResult   /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
131262     ** variables *piDataCur and *piIdxCur set to illegal cursor numbers
131315 **    *   The index is over the same set of columns
131390   ExprList *pEList;                /* The result set of the SELECT */
131451     return 0;   /* The result set must have exactly one column */
131455     return 0;   /* The result set must be the special operator "*" */
131622     ** DBFLAG_Vacuum flag is set, this block generates code to make
131623     ** that determination. If DBFLAG_Vacuum is set, then the destination
132299   char **pzErrMsg,                   /* Used to set error string on failure. */
132889   ** The original API set ends here.  All extensions can call any
133437 ** set of routines that is invoked for each new database connection, if it
133489 ** If anything goes wrong, set an error in the database connection.
133566 ** ../tool/mkpragmatab.tcl.  To update the set of pragmas, edit
134448 ** set these values for all pagers.
134756   ** Older versions of SQLite would set the default cache size to a
134804   ** database page size value.  The value can only be set if
134911         ** set on all attached databases, as well as the main db file.
134913         ** Also, the sqlite3.dfltLockMode variable is set so that
134987   ** Get or set the size limit on rollback journal files.
135007   ** Get or set the value of the database 'auto-vacuum' parameter.
135020       /* Call SetAutoVacuum() to set initialize the internal auto and
135110   ** or off.  When turnning cache spill on, the size is set to the
135149   ** Used to set mapping size limit. The mapping size limit is
135151   ** database file. If this parameter is set to zero, then memory mapping
135153   ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
135157   ** as little or as much as it wants.  Except, if N is set to 0 then the
135194   ** Return or set the local value of the temp_store flag.  Changing
135214   ** Return or set the local value of the temp_store_directory flag.  Changing
135258   ** Return or set the local value of the data_store_directory flag.  Changing
135300   ** Return or set the value of the lock_proxy_file flag.  Changing
135324         sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
135336   ** Return or set the local value of the synchronous flag.  Changing
135366       u64 mask = pPragma->iArg;    /* Mask of bits to set or clear. */
135410   ** the returned data set are:
135909     ** then iDb is set to the index of the database identified by <db>.
135914     ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb
136390   ** The pragma's schema_version and user_version are used to set or get
136567   ** (1) MASK bit 0x02 is set.
136644   ** if one is set.  If no busy handler or a different busy handler is set
136681   ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap
136685   ** the hard heap limit.  This allows an application to set a heap limit
136818   ** PragFlg_NoColumns1 flag is set and the caller specified an argument
137261     ** But because db->init.busy is set to 1, no VDBE code is generated
137438   ** main database, set sqlite3.enc to the encoding of the main database.
137446       /* If opening the main database, set ENC(db). */
137536     /* Hack: If the SQLITE_NoSchemaError flag is set, then consider
137577 ** After a database is initialized, the DB_SchemaLoaded bit is set
137578 ** bit is set in the flags field of the Db structure.
137631 ** of date set pParse->rc to SQLITE_SCHEMA.  If all schema cookies
137662     ** set Parse.rc to SQLITE_SCHEMA. */
137754 ** pParse->earlyCleanup flag is set in that case.  Calling code show verify
137874   ** works even if READ_UNCOMMITTED is set.
138554 ** When found, set *piTab and *piCol to the table index and column index
138593 ** And set the Expr.w.iJoin to iTable for every term in the
139072 **     table is not required. Instead, the current set of values
139221 ** The ExprList_item.fg.bSorterRef flag is set for each expression in pEList
139225 ** output variable (*ppExtra) is set to an expression list containing
139319   ** containing the current result row. In this case regOrig is set to the
139322   ** from this array. In this case regOrig is set to zero.  */
139396       ** the ORDER BY clause (pSort->pOrderBy), set the associated
139584     /* If we are creating a set for an "expr IN (SELECT ...)" construct,
139586     ** item into the set table with bogus data.
139591         ** ORDER BY in this case since the order of entries in the set
139608     /* If any row exist in the result set, record that fact and abort.
139780 ** implement that clause.  If the ExprList is the result set of a SELECT
140085 ** result-set expression in all of the following SELECT statements is
140155         ** sub-select. In this case, set the column type to NULL, even
140169         ** data for the result-set column of the sub-select.
140221       ** origin info for the single column in the result set of the SELECT
140252 ** in the result set.
140257   ExprList *pEList    /* Expressions defining the result set */
140394 ** that form the result set of a SELECT statement) compute appropriate
140424   int nCol;                   /* Number of columns in the result set */
140583 ** the result set of that SELECT.
140705 ** the result set for the compound-select statement "p".  Return NULL if
140779 ** The setup-query runs once to generate an initial set of rows that go
141354     KeyInfo *pKeyInfo;            /* Collating sequence for the result set */
141357     int nCol;                     /* Number of columns in result set */
141491     /* If we are creating a set for an "expr IN (SELECT ...)".
141614 ** within the output subroutine.  The regPrev register set holds the previously
141686   u32 *aPermute;        /* Mapping from ORDER BY terms to result set columns */
141706   ** the ORDER BY clause covers every term of the result set.  Add
141981 ** has the nullRow flag set, because the expression is an integer constant,
141983 ** that checks to see if the nullRow flag is set on the table.  If the nullRow
141984 ** flag is set, then the value in the register is set to NULL and the original
141985 ** expression is bypassed.  If the nullRow flag is not set, then the original
142020 ** whose result set is defined by pEList appears as entry in the
142024 ** of the subquery rather the result set of the subquery.
142197 ** new cursor number assigned, set an entry in the aCsrMap[] array
142206 ** on the FROM clause of each such sub-select, with iExcept set to -1.
142405 **        (17h) The corresponding result set expressions in all arms of the
142488   int iParent;        /* VDBE cursor number of the pSub result set temp table */
142822     /* Now begin substituting subquery result set expressions for
143392 ** If the query is a candidate for the min/max optimization, then set
143621 ** If a non-NULL value is returned, set *ppContext to point to the With
143967 **    (4)  Scan the list of columns in the result set (pEList) looking
144123     ** If we get here it means the result set contains one or more "*"
144125     ** in the result set and expand them one by one.
144162           ExprList *pNestedFrom;       /* Result-set of a nested FROM clause */
144220             ** result-set list unless the SELECT has the SF_IncludeHidden
144221             ** bit set.
144313       sqlite3ErrorMsg(pParse, "too many columns in result set");
144322     SELECTTRACE(0x100,pParse,p,("After result-set wildcard expansion:\n"));
144374 ** information to the Table structure that represents the result set
144377 ** The Table structure that represents the result set was constructed
144460 ** The aggregate accumulator is a set of memory cells that hold
144570         ** the first row (regAcc contains 1), set the magnet register so that
144669     ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
144975   /* If the SF_UFSrcCheck flag is set, then this function is being called
144995     ** and leaving this flag set can cause errors if a compound sub-query
145107     /* If the outer query contains a "complex" result set (that is,
145108     ** if the result set of the outer query uses functions or subqueries)
145119     ** The requirement that the outer query have a complex result set
145285       ** set on each invocation.
145408     ** the sDistinct.isTnct is still set.  Hence, isTnct represents the
145473   /* Open an ephemeral index to use for the distinct set.
145576     /* Remove any and all aliases between the result set and the
145604         ** So set the ASC/DESC flags in the GROUP BY to match those in the
145924       ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
145932       VdbeComment((v, "set abort flag"));
146063         ** minMaxFlag will have been previously set to either
146123   ** set the return code to 1. Otherwise 0. */
146522   ** then set iDb to 1 to create the trigger in the temporary database.
146813 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
147018 ** is set on.
147267 /* The input list pList is the list of result set terms from a RETURNING
147271 ** any "*" wildcards to be the complete set of columns from pTab.
147785 ** Bit 0 of the returned mask is set if the left-most column of the
147786 ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
147798 ** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
147799 ** included in the returned mask if the TRIGGER_BEFORE bit is set in the
147801 ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
147979 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
148230   /* If there was a FROM clause, set nChangeFrom to the number of expressions
148231   ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
148374   ** set to any non-negative number.  We use 99999 so that the value is
148400   ** case, set all bits of the colUsed mask (to ensure that the virtual
148715   /* If the rowid value will change, set register regNewRowid to
149698   ** restored before returning. Then set the writable-schema flag, and
149716   ** can be set to 'off' for this file, as it is not recovered if a crash
149747     /* For a VACUUM INTO, the pager-flags are set to the same values as
149749     ** is always set. */
149955 ** sqlite3.pVtabCtx member variable is set to point to an instance of
150580       ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from
150698 ** If an error occurs, *pzErr is set to point to an English language
150739 ** This function is used to set the schema of a virtual table.  It is only
151484 /* The WhereOrSet object holds a set of possible WhereOrCosts that
151548 ** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR
151553 ** categories, then eOperator==0.  The WhereTerm.pExpr field is still set
151554 ** to the original subexpression content and wtFlags is set up appropriately
151666 ** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to
151675 ** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to
151727   unsigned char bldFlags1;  /* First set of SQLITE_BLDF_* flags */
151728   unsigned char bldFlags2;  /* Second set of SQLITE_BLDF_* flags */
151772   ExprList *pResultSet;     /* Result set of the query */
152447       ** iOrderByCol variables. These are set to non-zero when an
152449       ** result-set. Since the result-set of the SELECT statement may
152451       ** set correctly.  Since setting them is just an optimization,
152673 ** Before returning, *pzAff is set to point to a buffer containing a
152676 ** with equality constraints that use BLOB or NONE affinity are set to
152686 ** string in this example would be set to SQLITE_AFF_BLOB.
152800 ** set P3 and P5 on the OP_String opcode so that the string will be cast
152850 ** accessed through the index.  If it cannot, then set pWalker->eCode to 1.
152871 ** a TK_COLUMN node that does affect the value of the expression is set
153064 ** enable this optimization, the P3 of OP_DeferredSeek is set to iIdxCur
153065 ** and P4 is set to an array of integers containing one entry for each column
153067 ** column of the index, then the corresponding array entry is set to (i+1).
153068 ** If the column does not appear in the index at all, the array entry is set
153185 ** WhereLevel.regFilter set.  If an inner-loop Bloom filter is checked,
153201     /*         ,--- Because sqlite3ConstructBloomFilter() has will not have set
153708     /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses
153875         ** over that initialization, leaving the range-end value set to the
154242               ** the row has already been included in the result set and
154290           ** terms, set pCov to the candidate covering index. Otherwise, set
154370   ** computed using the current set of tables.
154426         /* If the TERM_LIKECOND flag is set, that means that the range search
154563     ** of pTab, with all tables to left begin set to NULL.
155039 ** is a match, set *ppLeft to the "column" expression, set *ppRight to the
155041 ** right and the expression is on the left).  Also set *peOp2 to the
155264 ** A single subterm might be a set of AND-connected sub-subterms.
155299 ** If all subterms are indexable by a single table T, then set
155309 ** subterms have their eOperator set to WO_AND and they have
155310 ** u.pAndInfo set to a dynamically allocated WhereAndTerm object.
155333 ** If none of cases 1, 2, or 3 apply, then leave the eOperator set to
155372   ** Compute the set of tables that might satisfy cases 1 or 3.
155429   ** Record the set of tables that satisfy case 3.  The set might be
155454   ** chngToIN holds a set of tables that *might* satisfy case 1.  But
155463   ** "table.column=expr" for some single table.  The one bit that is set
155501           ** chngToIN set but t1 is not.  This term will be either preceded
155663 ** FALSE (0) if not.  If TRUE is returned, also set aiCurCol[0] to the cursor
155743 ** and the copy has idxParent set to the index of the original term.
156149   /* Add a WO_AUX auxiliary term to the constraint set if the
156788 ** iCursor is not in the set.
157141   ExprList *pDistinct       /* The result set that needs to be DISTINCT */
157367 ** and to set up the WhereLevel object pLevel so that the code generator
157589 ** flag set, initialize a Bloomfilter for them as well.  Except don't do
157594 ** from the loop, but the regFilter value is set to a register that implements
157602 ** is set.
157979 ** into the aSample[] array - it is an index into a virtual set of samples
158008   ** to pRec. If pRec contains a single field, the set of samples to search
158014   ** consider prefixes of those samples. For example, if the set of samples
158025   ** the code actually searches this set:
158211 ** Value pLoop->nOut is currently set to the estimated number of rows
158228 ** set to zero. If pUpper is NULL, or a value cannot be extracted from it,
158229 ** U is set to N.
158314 ** bound, a lower bound, or both. The WHERE clause terms that set the upper
158333 ** then nEq is set to 1 (as the range restricted column, b, is the second
158338 ** then nEq is set to 0.
158340 ** When this function is called, *pnOut is set to the sqlite3LogEst() of the
158375       /* Variable iLower will be set to the estimate of the number of rows in
158387       ** Similarly, iUpper is to be set to the estimate of the number of rows
159559     /* At this point pNew->nOut is set to the number of rows expected to
159617                 ** higher selectivity, then set the flag to rerun the
159641     ** it to pNew->rRun, which is currently set to the cost of the index
159816 ** If the index does not cover the column, then set pWalk->eCode to
159902 ** where K is a value between 1.1 and 3.0 set based on the relative
160218 ** Output parameter *pbIn is set to true if the plan added to pBuilder
160431 ** false otherwise. If iCons is an IN(...) constraint, set (if bHandle!=0)
160451 ** If possible, set (*ppVal) to point to an object containing the value
160525 ** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause
160621     ** in the set of terms that apply to the current virtual table.  */
160779         /* TUNING: Currently sSum.a[i].rRun is set to the sum of the costs
160874         /* We hit the query planner search limit set by iPlanLimit */
160944   ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags.
160946   ** We say the WhereLoop is "order-distinct" if the set of columns from
161231 ** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(),
161337   LogEst mxCost = 0;        /* Maximum cost of a set of paths */
161338   LogEst mxUnsorted = 0;    /* Maximum unsorted cost of a set of path */
161383     /* If there is an ORDER BY clause and it is not being ignored, set up
161407     ** indicate this. Or, if nLoop is greater than zero, set isOrdered to
161408     ** -1, indicating that the result set may or may not be ordered,
161481         /* Check to see if pWLoop should be added to the set of
161485         ** that covers the same set of loops and has the same isOrdered
161518           ** needs to be added to the set of best-so-far paths. */
161520             /* Increase the size of the aTo set by one */
161536           ** same set of loops and has the same isOrdered setting as the
161580         /* pWLoop is a winner.  Add it to the set of best so far */
162159 ** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement
162164 ** WHERE_OR_SUBCLAUSE is set, iIdxCur is the cursor number of an index
162166 ** specific cursor.  If WHERE_ONEPASS_DESIRED is set, then iIdxCur is
162176   ExprList *pResultSet,   /* Query result set.  Req'd for DISTINCT */
162179   int iAuxArg             /* If WHERE_OR_SUBCLAUSE is set, index cursor number
162188   WhereMaskSet *pMaskSet;    /* The expression mask set */
162223   ** pTabList.  But if the WHERE_OR_SUBCLAUSE flag is set, then we should
162304     ** WHERE_OR_SUBCLAUSE flag is set.
162352       /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via
162360       /* Try to ORDER BY the result set to make distinct processing easier */
162513   ** use a one-pass approach, and this is not set accurately for scans
162606       /* iAuxArg is always set to a positive value if ONEPASS is possible */
162984     ** all of the columns of the left operand set to NULL.
163300 ** the window frame has been set to:
163330 ** is not set to the default value "NO OTHERS".
163419 ** the window frame has been set to:
163450 ** the window frame has been set to:
163495 ** the window frame has been set to:
164214         ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get
164235     ** result-set or ORDER BY clause of the SELECT statement p.  */
164371 ** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the
164674 **   ordinary aggregate function does). This variable is set to the first
164718 **   be required. In this case both WindowCodeArg.csr and reg are set to
165111 ** Generate code to set the accumulator register for each window function
165259   /* If the BIGNULL flag is set for the ORDER BY, then it is required to
165263   ** instead if the BIGNULL flag is set then cases where either reg1 or
165327   ** control skips over this test if the BIGNULL flag is set and either
168745 ** coverage.  The element yycoverage[X][Y] is set when the parser
168747 ** systems, every element of this matrix should end up being set.
170448   sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy322,"set list");
171617       ** Applications can set this macro (for example inside %include) if
172319 ** For ASCII, any character with the high-order bit set is
172358 ** Return the id of the next token in string (*pz). Before returning, set
172869     /* If the pParse->declareVtab flag is set, do not delete any table
173438 ** succeeds, except that it fails if the fault-simulation is set
173532 ** the SQLITE_THREADSAFE compile-time option being set to 0.
173538 ** this variable being set to non-zero will cause OSTRACE macros to emit
173622   ** combination, the work-around is to set the correct pointer
173628   ** must be complete.  So isInit must not be set until the very end
174083       ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
174368         u32 mask;    /* Mask of the bit in sqlite3.flags to set/clear */
176218 ** Make sure the hard limits are set to reasonable values
176276   ** there is a hard upper bound set at compile-time by a C preprocessor
176324 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
176325 ** the VFS that should be used to open the database file. *pzFile is set to
176333 ** may be set to point to a buffer containing an English language error
176364     /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
176405     ** Within this loop, variable eState may be set to 0, 1 or 2, depending
177186 **   1.  Serve as a convenient place to set a breakpoint in a debugger
177336   /* Whether the function call succeeded or failed, set the output parameters
177757     ** provided to set a small and easily reachable reset value.
177924     ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
178422 **      set to db. This is used when closing connection db.
178583 **      set to db, then set pBlockingConnection=0.
178586 **      set to db, then invoke the configured unlock-notify callback and
178587 **      set pUnlockConnection=0.
178810 ** a single docid.  A "column-list" is the set of positions for a single
179095   ** Structure version. Should always be set to 0 or 1.
179107   ** then argc is set to 2, and the argv[] array contains pointers
179111   ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
179147   ** method should either return SQLITE_OK and set the values of the
179151   ** *ppToken should be set to point at a buffer containing the
179153   ** stemming has been performed). *pnBytes should be set to the length
179156   ** *piEndOffset. *piStartOffset should be set to the index of the first
179157   ** byte of the token in the input buffer. *piEndOffset should be set
179161   ** The buffer *ppToken is set to point at is managed by the tokenizer
179377 ** in the document set and zero or more prefix indexes. All indexes are stored
179552   ** terms that appear in the document set. Each subsequent index in aIndex[]
179634 ** The Fts3Cursor.eSearch member is always set to one of the following.
179643 ** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1.  (+0 for a,
179646 ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
179653 ** The lower 16-bits of the sqlite3_index_info.idxNum value set by
179964 ** This variable is set to false when running tests for which the on disk
180525 ** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If
180582 ** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If
180662 ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
180663 ** the allocated array. *pnIndex is set to the number of elements in the
180848   char **azNotindexed = 0;        /* The set of notindexed= columns */
181338   /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */
181450 ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
181522 ** If piLast is not NULL, then *piLast is set to the right-most child node
181640 ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
181642 ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
181729 ** to *pp. *pp is set to point to the first byte past the last byte copied
181738   ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
181742   ** immediately preceded by a byte with the 0x80 bit set. Then increments
181775 ** to *pp. *pp is set to point to the first byte past the last byte copied
181814 ** If *pp points past the end of the current position-list, set *pi to
181816 ** increment the current value of *pi by the value read, and set *pp to
181980   /* Never set both isSaveLeft and isExact for the same invocation. */
182138 ** has been reached. In this case *pp is set to 0 and the function returns.
182141 ** from *pp. *pp is then set to point 1 byte past the end of the read varint.
182168 ** is written to *pp. Before returning, *pp is set to point 1 byte past the
182223 ** If no error occurs, *paOut is set to point at an sqlite3_malloc'd buffer
182225 ** *pnOut is set to the number of bytes in the output doclist.
182736 ** Output parameter *ppSegcsr is set to 0 if an error occurs.
183058 ** routine to find out if it has reached the end of a result set.
183071 ** retrieve the rowid for the current row of the result set. fts3
183207 ** table (if p->bHasStat==2), attempt to determine this (set p->bHasStat
183291   ** have the 0x80 bit set.  */
183298   ** set. So to find the start of the poslist, skip forward 2 bytes then
184272 ** entry. Or, if the iterator has reached EOF, set *pbEof to true.
184322 ** If there is no "next" entry and no error occurs, then *pbEof is set to
184324 ** successfully advanced, *pbEof is set to 0.
184340   ** one incremental token. In which case the bIncr flag is set. */
184426 ** If there is no "next" entry and no error occurs, then *pbEof is set to
184428 ** successfully advanced, *pbEof is set to 0.
184457 ** expression. Also the Fts3Expr.bDeferred variable is set to true for any
184466 ** If an error occurs within this function, *pRc is set to an SQLite error
184519 ** Otherwise, if an error occurs during execution, *pRc is set to an
184600     testcase( a==0 );  /* If %_stat.value set to X'' */
184846 ** Before returning, *paPoslist is set to point to the position lsit
184847 ** associated with pPhrase. And *pnToken is set to the number of tokens in
184892 ** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if
184893 ** successful, the following variables in pExpr are set:
185147 ** If an error occurs during execution of this function, *pRc is set to
185315   ** by Fts3Cursor.iMinDocid/iMaxDocid. If so, set the EOF flag.  */
185332 ** a no-op. If an error occurs within this function, *pRc is set to an
185521 **     values are set to the number of documents in the table. In other
186359 ** to zero causes the module to use the old syntax. If it is set to
186408 **   FTS3 query "sqlite -mysql". Otherwise, ParseContext.isNot is set to
186487 ** single token and set *ppExpr to point to it. If the end of the buffer is
186488 ** reached before a token is found, set *ppExpr to zero. It is the
186589 ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
186591 ** error) or SQLITE_ERROR (tokenization error) is returned and *ppExpr set
186706 ** structure, or set to 0 if the end of the input buffer is reached.
186898 ** of the tree changing, in which case *ppHead is set to the new root node.
186926 ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
186927 ** parsed form of the expression and *pnConsumed is set to the number of
186928 ** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLITE_NOMEM
186978           /* The isRequirePhrase variable is set to true if a phrase or
186981           ** isRequirePhrase is set, this is a syntax error.
187098 ** If successful, SQLITE_OK is returned and (*pp) set to point to the
187276 **   3. Even if it fails, *ppExpr may still be set to point to an
187323 ** parsed expression. If successful, *ppExpr is set to point to the head
187326 ** error) is returned and *ppExpr is set to 0.
187930 ** flag is set.  NULL is returned.
188324 ** Any upper-case characters in the US-ASCII character set ([A-Z])
188641 ** The set of routines that implement the porter-stemmer tokenizer
189401 ** The set of routines that implement the simple tokenizer
189457 ** fields set as follows:
189459 **   input:   Always set to a copy of <string>
189528 ** If successful, output parameter *pazDequote is set to point at the
190009 ** a contiguous set of segment b-tree leaf nodes. Although the details of
190041   /* Variables set by fts3SegReaderNext(). These may be read directly
190166 ** *pp is set to the requested statement handle and SQLITE_OK returned.
190167 ** Otherwise, an SQLite error code is returned and *pp is set to 0.
190571 ** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning.
190573 ** it is set to SQLITE_OK.
191010 ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
191066 ** identified table row is. Whether or not paBlob is NULL, *pnBlob is set
191355 ** *ppOffsetList is set to point to the first column-offset list
191357 ** *pnOffsetList is set to the length of the set of column-offset
191424     /* If there are no more entries in the doclist, set pOffsetList to
191425     ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
191830 ** Find the largest relative level number in the table. If successful, set
191832 ** set *pnMax to zero and return an SQLite error code.
192045 ** set output variables *paRoot and *pnRoot to contain the root node.
192048 ** set to the largest blockid written to the database (or zero if no
192323 ** If successful, *pisEmpty is set to true if the table is empty except for
192385 ** within its index. Assuming no error occurs, *pbMax is set to 1 if
192502 ** *pnList is set to zero before returning.
192967 ** by one or more space (0x20) characters. In the first case, set *piEndBlock
192969 ** set *piEndBlock to the first value and *pnByte to the second.
193058         ** updated it to set (level = -1) and (idx = N), where N is 0 for the
193313 ** varints are set as follows:
193635 ** If an OOM error occurs, set *pRc to SQLITE_NOMEM and leave pBlob->a
193658 ** (e.g. because the current entry is the last) set NodeReader->aNode to
193712 ** If successful, SQLITE_OK is returned and the NodeReader object set to
193980 ** flushing buffers to disk, *pRc is set to an SQLite error code before
193995   ** will be set to 0. If the root node is the parent of the leaves, iRoot
194093 ** NULL. If no error occurs and the entry is NULL, set *pbRes 1 before
194094 ** returning. Otherwise, set *pbRes to 0.
194104   int bRes = 0;                   /* Result to set *pbRes to */
194278 ** level iAbsLevel+1. If no error occurs, set *piIdx to this value plus
194280 ** within level iAbsLevel, set *piIdx to zero.
194746 ** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs,
194747 ** set *pRc to an SQLite error code before returning.
194827     ** If one is found, set iAbsLevel to the absolute level number and
194829     ** set nSeg to -1.
195090 ** If successful, the checksum value is returned and *pRc set to SQLITE_OK.
195091 ** Otherwise, if an error occurs, *pRc is set to an SQLite error code. The
195165 ** content table. If no error occurs and the contents do match, set *pbOk
195166 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
195263 ** prefix in the document set, a 64-bit checksum is calculated (by code
196017 ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
196020 ** pnToken is not NULL, then it is set to the number of tokens in all
196214 **       the snippet for which the corresponding mCovered bit is not set.
196256   ** the set of phrases in the expression to populate the aPhrase[] array.
196543 ** Before returning, *ppCollist is set to point to the first byte after
196645 ** Y values are set to nDoc, where nDoc is the number of documents in the
196796 ** If LcsIterator.iCol is set to the following value, the iterator has
198113   ** need to be folded). Or, if it is set, then the rule only applies to
198332 /* The "subtype" set for JSON values */
198836 #if 0 /* Never happens because JNODE_RAW is only set by json_set(),
199339 ** new nodes are appended *pApnd is set to 1.
199531 ** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
199767 ** If JSON_JSON is set or if more that one PATH argument is supplied then
199768 ** always return a JSON representation of the result.  If JSON_SQL is set,
200117     jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert");
201369 ** Note that the GCC_VERSION macro will also be set correctly when using
201416 ** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined
201558 ** Clear the content of node p (set all bytes to 0x00).
201707   /* If the root node was just loaded, set pRtree->iDepth to the height
201722   ** field on the node is too large. If so, set the return code to
202214 ** set *peWithin to NOT_WITHIN.
202265 ** If this constraint is not satisfied, set *peWithin to NOT_WITHIN.
202551 ** contains an entry suitable for returning as a result-set row,
202717 ** rowid iRowid. If successful, set *ppLeaf to point to the node and
202718 ** return SQLITE_OK. If there is no such record in the table, set
202719 ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
203263 ** nIdx. The aIdx array contains the set of integers from 0 to
203335 ** nIdx. The aIdx array contains the set of integers from 0 to
204903 ** and RtreeCheck.rc==SQLITE_OK, set RtreeCheck.rc to the error code.
204975 ** is set to the size of the buffer in bytes.
205022 ** IPK value iKey and the second column set to iVal.
208147 ** The set of routines that implement the simple tokenizer
208288 ** working set of leaves is larger than the available cache memory, then a
208348 ** named "data_<target name>" containing the same set of columns as the
208404 ** with the "rbu_control" column set to contain integer value 0. The
208405 ** other columns should be set to the values that make up the new record
208414 ** with the "rbu_control" column set to contain integer value 1. The
208421 ** with the "rbu_control" column set to contain a value of type text.
208428 ** each column that is being updated, the corresponding character is set to
208430 ** rbu_control value should be set to '.'. For example, given the tables
208440 ** for UPDATEs may also be set to 'd'. In this case, instead of updating the
208713 ** *pzErrmsg may be set to point to a buffer containing a utf-8 formatted
208745 ** (*pnOne) is set to 10000 to indicate that stage 1 has finished and (*pnTwo)
208751 ** (*pnTwo) is set to 0 to indicate that stage 2 has not yet started. The
208752 ** value to which (*pnOne) is set depends on whether or not the RBU
208764 ** API is called during stage 1, the *pnOne output variable is set to the
208766 ** not exist, then (*pnOne) is set to -1 during stage 1. If the rbu_count
208935 **   May be set to integer values 1, 2, 4 or 5. As follows:
209061 **   If the table has no indexes on it, abIndexed is set to NULL. Otherwise,
209063 **   set for each column that is either a part of the PK or a part of an
209067 **   this array set set to 1. This is because in that case, the module has
209079   u8 *abTblPk;                    /* Array of flags, set on target PK columns */
209080   u8 *abNotNull;                  /* Array of flags, set on NOT NULL columns */
209081   u8 *abIndexed;                  /* Array of flags, set on indexed & PK cols */
209151 **   If the RBU database contains an rbu_count table, this value is set to
209249 ** "sz" is set to the current size of the database file.
209530 ** If successful, set *ppStmt to point to the new statement and return
209533 ** Otherwise, if an error does occur, set *ppStmt to NULL and return
209534 ** an SQLite error code. Additionally, set output variable *pzErrmsg to
209556 ** If an error has occurred, then set *pzErrmsg to point to a buffer
209572 ** compilation is successful, *ppStmt is set to point to the new statement
209575 ** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code
209576 ** returned. In this case, *pzErrmsg may also be set to point to an error
209581 ** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL.
209819 ** If an error has already occurred (p->rc is already set to something other
209918 ** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise,
209943 ** rbu handle error code is not already set, set the error code and error
209970 **   (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
209972 **   is set to the root page number of the primary key index before
210697 ** column of the data_xxx table entry is set to zMask.
211392 ** is not an error. Output variable *ppStmt is set to NULL in this case.
211747 ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
211753 ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
211801 ** It populates the sqlite3rbu.aFrame[] array with the set of
211803 ** current wal file, and obtains the set of shm locks required to safely
211809 ** object, then the rbu handle is set to DONE state. This occurs if some
211826   ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following
211848   ** array populated with a set of (frame -> page) mappings. Because the
212087 ** If RBU_UPDATE is returned, then output variable *pzMask is set to
212293 ** Or, if this is an RBU vacuum, set the schema cookie of the main db
212749     ** occurs, nPhaseOneStep will be left set to -1. */
212814       ** flag it set, this means that the db was not opened because it seemed
212899           /* Check if the main database is a zipvfs db. If it is, set the upper
212941 ** error code, which is set to SQLITE_MISUSE.
213245 **    member variable of the associated database file descriptor is set
213262 **      * if the *-wal file does not exist, set the output parameter to
214304   sqlite3_stmt *pStmt;            /* Iterates through set of root pages */
214447   ** If this will satisfy the client, set the orderByConsumed flag so that
215623 ** Each session object maintains a set of the following structures, one
215652 ** change-set binary format, and so must be architecture independent.
215724 ** not modified by the UPDATE change are set to "undefined". Other fields
215725 ** are set to the values that made up the row before the UPDATE that the
215729 ** are set to "undefined".
215761 ** columns and columns that are modified by the UPDATE are set to "undefined".
215767 ** change to contain a field set to "undefined".
215793 ** In a rebase blob, the first field is set to SQLITE_INSERT if the change
215795 ** it was a DELETE. The second field is set to 0x01 if the conflict
215875 ** buffer aBuf. *pnWrite is set to the number of bytes written before
215877 ** set *pnWrite.
216024 ** values, *pbNullPK is set to true before returning.
216028 ** and the output variables are set as described above.
216196 ** then set to point to one byte after the last byte written before
216242 ** pointer is returned and *pnVal is set to the number of bytes in the
216244 ** set to the number of bytes in the value at *paOne. If *paOne points
216245 ** to the "no value" placeholder, *pnVal is set to 1. In other words:
216432 ** (part of the session pSession). If a fatal OOM error occurs, set the
216486 ** Otherwise, if they are not NULL, variable *pnCol is set to the number
216487 ** of columns in the database table and variable *pzTab is set to point to a
216488 ** nul-terminated copy of the table name. *pazCol (if not NULL) is set to
216490 ** NULL) is set to point to an array of booleans - true if the corresponding
216636 ** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
216638 ** is set to NULL in this case.
217510 ** set *pRc to SQLITE_NOMEM and return non-zero.
217552 ** Otherwise, if an error occurs, *pRc is set to an SQLite error code
217574 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
217587 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
217600 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
217620 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
217640 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
217659 ** If an OOM condition is encountered, set *pRc to SQLITE_NOMEM before
218027 ** This function is a no-op if *pRc is set to other than SQLITE_OK when it
218029 ** changeset format) to buffer *pBuf. If an error occurs, set *pRc to an
218052 ** occurs, an SQLite error code is returned and both output variables set
218502 ** to deserialize. Assuming no error occurs, *paChange is set to point to
218509 ** is set to point to an sqlite3_value object containing the value read
218513 ** set to NULL.
218640 ** If successful, SQLITE_OK is returned and *pnByte is set to the size of
218956 ** was not modified and is not a PK column), set *ppValue to NULL.
218984 ** was not modified), set *ppValue to NULL.
219017 ** If successful, *ppValue is set to point to an sqlite3_value structure
219188         ** are set to "undefined". */
219475 ** Variable :5 (nCol+1) is a boolean. It should be set to 0 if we require
219637   ** set to SQLITE_NULL.  */
219812 ** is set to non-zero before returning SQLITE_OK.
219901 ** invoke the conflict handler. If it returns CHANGESET_REPLACE, set *pbRetry
219903 ** again, this time with pbRetry set to NULL.
219908 ** an invocation returns SQLITE_CHANGESET_REPLACE, set *pbReplace to true
219910 ** row before invoking this function again, this time with pbReplace set
219939     ** bind values for all columns and set bound variable (nCol+1) to true.
219941     ** values and, if it exists, set (nCol+1) to false. Conflict handling
220063     /* If the bRetry flag is set, the change has not been applied due to an
220075     /* If the bReplace flag is set, the change is an INSERT that has not
220777 ** this case (*pnOut) is set to the size of the output buffer in bytes. It
220783 ** are both set to 0 before returning.
221028 **     in the rebase buffer is set to "replaced" (type 0xFF). If this
221096 ** then (*ppOut) is set to point to a buffer containing the rebased changeset
221097 ** before this function returns. In this case (*pnOut) is set to the size of
221102 ** pnOut are not NULL, then the two output parameters are set to 0 before
221415 **   If parameter iCol is less than zero, set output variable *pnToken
221430 **   If parameter iCol is less than zero, set output variable *pnToken
221432 **   non-negative but less than the number of columns in the table, set
221445 **   current document. If successful, (*pz) is set to point to a buffer
221446 **   containing the text in utf-8 encoding, (*pn) is set to the size in bytes
221474 **   Usually, output parameter *piPhrase is set to the phrase number, *piCol
221494 **   with $p set to a phrase equivalent to the phrase iPhrase of the
221534 **   the auxiliary data is set to NULL and an error code returned. If the
221545 **   (set to NULL) before this function returns. In this case the xDelete,
221582 **   through an empty set (all calls to xPhraseFirst() set iCol to -1).
221591 **   APIs are used to iterate through the set of columns in the current row
221606 **   then this API always iterates through an empty set (all calls to
221607 **   xPhraseFirstColumn() set iCol to -1).
221619   int iVersion;                   /* Currently always set to 3 */
221682 **   should be set to point to the new tokenizer handle and SQLITE_OK
221704 **            determine the set of tokens to add to (or delete from) the
221731 **   normally be set to 0. The exception is if the tokenizer supports
221750 **   of "first place" within the document set, but not alternative forms
221891   int iVersion;                   /* Currently always set to 2 */
222000 ** less than 32. If it is set to anything large than that, an #error
222055 /* If a NEAR() clump or phrase may only match a specific set of columns,
222056 ** then an object of the following type is used to record the set of columns.
222104 **   This is only used for debugging. If set to false, any prefix indexes
222271 /* Character set tests (like isspace(), isalpha() etc.) */
222426 ** Get or set the "averages" values.
223481 ** coverage.  The element fts5yycoverage[X][Y] is set when the parser
223483 ** systems, every element of this matrix should end up being set.
224223       ** Applications can set this macro (for example inside %include) if
224305 ** common), each set of overlapping instances is treated as a single
224412 ** If *pRc is set to any value other than SQLITE_OK when this function is
224414 ** *pRc is set to an error code before returning.
224888         ** where "N" is the total number of documents in the set and nHit
224895         ** half of set of 5,000,000 documents.  */
225037 ** pBuf. If an OOM error occurs, set the error code in p.
225056 ** Append buffer nData/pData to buffer pBuf. If an OOM error occurs, set
225075 ** ensures that the byte following the buffer data is set to 0x00, even
225093 ** following the buffer data is set to 0x00, even though this byte is not
225227 ** The previous position written to this list is *piPrev. *piPrev is set
225815 ** Before returning, set pzOut to point to a new buffer containing a
225817 ** quoted, *pbQuoted is also set to 1 before returning.
225821 ** function, *pRc is set to SQLITE_NOMEM before returning. *pRc is *not*
225822 ** set if a parse error (failed to find close quote) occurs.
225919 ** If successful, SQLITE_OK is returned and *ppOut is set to point to the
225921 ** returned, *ppOut is set to NULL and an error message may be left in
226906 ** is set to true if this is really a match, or false otherwise.
227034 ** The near-set object passed as the first argument contains more than
227041 ** If in/out parameter (*pRc) is set to other than SQLITE_OK when this
227043 ** occurs within this function (*pRc) is set accordingly before returning.
227094     /* This block advances the phrase iterators until they point to a set of
227145 ** If the iterator reaches EOF, set *pbEof to true before returning. If
227146 ** an error occurs, set *pRc to an error code. If either *pbEof or *pRc
227147 ** are set, return a non-zero value. Otherwise, return zero.
227394 ** If an EOF is reached before this happens, *pbEof is set to true before
227795 ** match. If there are no matches, set the Node.bEof flag to indicate EOF.
227845 ** Begin iterating through the set of documents in index pIdx matched by
228429 ** If argument pOrig is NULL, or if (*pRc) is set to anything other than
228434 ** fails, (*pRc) is set to SQLITE_NOMEM and NULL is returned.
228476 ** of pColset. This function may use the spare copy and set (*ppFree) to
230075 **   The set of segments that make up an index - the index structure - are
230191 **         0x01: Clear if leaf is also the root page, otherwise set.
230204 **         0x01: Clear for root page, otherwise set.
230415 **     If set, set the iterator to point to EOF after the current doclist
230419 **     This flag is only ever set if FTS5_SEGITER_ONETERM is also set. If
230420 **     it is set, iterate through rowid in descending order instead of the
230424 **     These are used if the FTS5_SEGITER_REVERSE flag is set.
230427 **     corresponding aRowidOffset[] entry is set to the byte offset of the
230452   /* The following are only used if the FTS5_SEGITER_REVERSE flag is set. */
230463   u8 bDel;                        /* True if the delete flag is set */
230518   /* Invoked to set output variables. */
230572 ** If an OOM error is encountered, return NULL and set the error code in
230853 ** an error occurs, (*pRc) is set to an SQLite error code before returning.
230893 ** If an error occurs, *ppOut is set to NULL and an SQLite error code
230894 ** returned. Otherwise, *ppOut is set to point to the new object and
231395 ** The iterator passed as the first argument has the following fields set
231473       ** set. So the last 0x00 is only a varint 0 if there are 8 more 0x80
231622 ** read. Before returning, set *pnSz to the number of bytes in the position
231623 ** list, and *pbDel to true if the delete flag is set, or false otherwise.
231704 ** accordingly and leaves (Fts5SegIter.iLeafOffset) set to the content of
231756 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
231795 ** Fts5IndexQuery() with the FTS5INDEX_QUERY_DESC flag set.
231798 ** Fts5SegIter.iLeafOffset variable is set to the offset of the start of
231800 ** Fts5SegIter.rowid is set, but nPos and bDel are not.
232029 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. It
232217   ** pIter->iLeafOffset is already set to point to the position-list size
232427 ** pSeg. If there is no such term in the index, the iterator is set to EOF.
232429 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
232497   **   4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points
232510 ** iterator is set to EOF.
232512 ** If an error occurs, Fts5Index.rc is set to an appropriate error code. If
232640     /* Check that pIter->iSwitchRowid is set correctly. */
232839   int iMinset                     /* Minimum entry in aFirst[] to set */
233212 ** Or, if the new position list is a contiguous subset of the input, set
233216 ** called. If an OOM error is encountered, *pRc is set to SQLITE_NOMEM
233302     ** Fts5Iter.poslist buffer and then set the output pointer to point
233398     ** Fts5Iter.poslist buffer and then set the output pointer to point
233523   ** object and set the output variable to NULL.  */
233986 ** If an error occurs, set the Fts5Index.rc error code. If an error has
234082     /* If this is to be the first rowid written to the page, set the
234498 ** If an error occurs, set the Fts5Index.rc error code. If an error has
234512     /* Update the write-counter. While doing so, set nWork. */
234575 ** If an error occurs, set the Fts5Index.rc error code. If an error has
235406 ** If successful, set *pp to point to the new object and return SQLITE_OK.
235407 ** Otherwise, set *pp to NULL and return an SQLite error code.
235569   /* If the QUERY_SCAN flag is set, all other flags must be clear. */
235577     /* Figure out which index to search and set iIdx accordingly. If this
235578     ** is a prefix query for which there is no prefix index, set iIdx to
235819 ** Instead, it tests that the same set of pgno/rowid combinations are
236508 ** set to an SQLite error code before returning. The final state of buffer
236848 ** This variable is set to false when running tests for which the on disk
237356 **     cost is unconditionally set to 1e50 (a really big number).
237494   /* Calculate the estimated cost based on the flags set in idxFlags. */
237683 ** If the REQUIRE_RESEEK flag is set on the cursor passed as the first
237688 ** If the new rowid is not equal to the old, set output parameter *pbSkip
238163     ** set to FTS5_PLAN_SORTED_MATCH). pSortCsr is the cursor that will
238224 ** routine to find out if it has reached the end of a result set.
238248 ** retrieve the rowid for the current row of the result set. fts5
238277 ** If the cursor requires seeking (bSeekRequired flag is set), seek it.
240030 ** If successful, set *pp to point to the new object and return SQLITE_OK.
240031 ** Otherwise, set *pp to NULL and return an SQLite error code.
240239 ** argument bCache is true, set the p->bTotalsValid flag to indicate
240946 ** For tokenizers with no "unicode" modifier, the set of token characters
240947 ** is the same as the set of ASCII range alphanumeric characters.
241161   int eRemoveDiacritic;           /* True if remove_diacritics=1 is set */
242464   ** need to be folded). Or, if it is set, then the rule only applies to
243411 ** for all bytes that have the 8th bit set and one byte with the 8th
243484 **   One row for each term/column combination. The value of $doc is set to
243486 **   $term within column $col. Field $cnt is set to the total number of
243492 **   One row for each term in the database. The value of $doc is set to
243494 **   $term. Field $cnt is set to the total number of instances of term
243564 ** FTS5_VOCAB_XXX constant. If successful, set *peType to the output
243565 ** value and return SQLITE_OK. Otherwise, set *pzErr to an error message
243773   ** specifically - "ORDER BY term" or "ORDER BY term ASC" - set the
244137 ** routine to find out if it has reached the end of a result set.
244213 ** retrieve the rowid for the current row of the result set. The
244336 **        result set of queries against stmt will look like.
245025 // You should set all key infos including salt before you call this function
245312     sqlite3_log(SQLITE_NOMEM, "codec: alloc mem failed when set cipher page size(%d).", size);
245887     ** Make sure to set the Kdf algorithm after setting the Hmac algorithm, or it will not take effect. 
245948     ** Make sure to set the Kdf algorithm after setting the Hmac algorithm, or it will not take effect. 

Indexes created Thu Nov 07 10:32:03 CST 2024