Lines Matching refs:used
54 ** used on lines of code that actually
76 ** only used by test code and Tcl integration code.
83 ** Include the header file used to customize the compiler options for MSVC.
208 /* The GCC_VERSION and MSVC_VERSION macros are used to
210 ** value of 0 means that compiler is not being used. The
357 ** Be aware that these macros may not be used within this particular
360 ** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the
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
369 ** The SQLITE_STDCALL macro is no longer used and is now deprecated.
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
378 ** SQLITE_SYSAPI macros are used only when building for environments
404 ** These no-op macros are used in front of interfaces to mark those
410 ** These macros used to resolve to various kinds of compiler magic that
411 ** would generate warning messages when they were used. But that
438 ** numbers used in [SQLITE_VERSION].)^
549 ** This interface can be used by an application to make sure that the
776 #define SQLITE_MISUSE 21 /* Library used incorrectly */
779 #define SQLITE_FORMAT 24 /* Not used */
889 ** used as the third argument to the [sqlite3_open_v2()] interface.
1002 ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
1047 ** This object defines the methods used to perform various operations
1179 ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This
1187 ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
1195 ** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that
1204 ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
1213 ** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
1218 ** The [SQLITE_FCNTL_JOURNAL_POINTER] opcode is used to obtain a pointer
1249 ** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic
1266 ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
1269 ** files used for transaction control
1282 ** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
1295 ** transaction. This is used by VACUUM operations.
1298 ** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
1365 ** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the
1366 ** maximum number of bytes that will be used for memory-mapped I/O.
1372 ** file-control is used internally to implement [PRAGMA mmap_size].
1377 ** This file control is used by some VFS activity tracing [shims].
1389 ** The [SQLITE_FCNTL_WIN32_GET_HANDLE] opcode can be used to obtain the
1395 ** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging. This
1397 ** pointed to by the pArg argument. This capability is used during testing
1412 ** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by
1451 ** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS
1459 ** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to
1466 ** interface can be used to find if any database on the connection has changed,
1491 ** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect
1499 ** other process. This opcode cannot be used to detect transactions opened
1586 ** Type [sqlite3_filename] is used by SQLite to pass filenames to the
1625 ** structure used by this VFS. mxPathname is the maximum length of
1663 ** or [sqlite3_open16()] is used, then flags includes at least
1703 ** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
1707 ** SQLITE_OPEN_CREATE, is used to indicate that file should always
1709 ** It is <i>not</i> used to indicate the file should be opened
1727 ** flag is never actually used and is not implemented in the built-in
1761 ** are not used by the SQLite core. These optional interfaces are provided
1816 ** These integer constants can be used as the third parameter to
1825 ** The SQLITE_ACCESS_READWRITE constant is currently used only by the
1830 ** currently unused, though it might be used in a future release of
1958 ** The sqlite3_config() interface is used to make global configuration
1992 ** The sqlite3_db_config() interface is used to make configuration
2013 ** This object is used in only one place in the SQLite interface.
2027 ** also used during testing of SQLite in order to specify an alternative
2053 ** by xInit. The pAppData pointer is used as the only parameter to
2100 ** all mutexing and puts SQLite into a mode where it can only be used
2142 ** alternative low-level memory allocation routines to be used in place of
2152 ** This option can be used to overload the default memory allocation
2184 ** <dd> The SQLITE_CONFIG_SCRATCH option is no longer used.
2240 ** The argument specifies alternative low-level mutex routines to be used
2254 ** This option can be used to overload the default mutex allocation
2255 ** routines with a wrapper used to track mutex usage for performance
2269 ** option to [sqlite3_db_config()] can be used to change the lookaside
2284 ** <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite
2332 ** <dd> These options are obsolete and should not be used by new code.
2430 ** configuration setting is never used, then the default maximum is determined
2440 #define SQLITE_CONFIG_SCRATCH 6 /* No longer used */
2504 ** <dd> ^This option is used to enable or disable the enforcement of
2515 ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
2532 ** <dd> ^This option is used to enable or disable [CREATE VIEW | views].
2549 ** <dd> ^This option is used to enable or disable the
2563 ** <dd> ^This option is used to enable or disable the [sqlite3_load_extension()]
2580 ** <dd> ^This option is used to change the name of the "main" database
2593 ** operation before closing the connection. This option may be used to
2610 ** was used during testing in the lab.
2621 ** option is used to set or clear (the default) a flag that governs this
2788 ** names are not also used by explicitly declared columns. ^If
2892 ** ^This means that if the changes() SQL function (or similar) is used
2895 ** ^If it is used by the second or subsequent such statement within a trigger
3039 ** The sqlite3_busy_handler() interface is used to implement
3305 ** option is used.
3352 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
3354 ** already uses the largest possible [ROWID]. The PRNG is also used for
3414 ** return can be used to deny an untrusted user access to individual
3424 ** An authorizer is used when [sqlite3_prepare | preparing]
3450 ** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
3476 ** Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
3494 ** codes is used as the second parameter. ^(The 5th parameter to the
3534 #define SQLITE_COPY 0 /* No longer used */
3544 ** These routines register callback functions that can be used for
3555 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
3690 ** interrupted. This feature can be used to implement a
3714 ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
3744 ** it does not already exist. This is the behavior that is always used for
3815 ** a NULL pointer then the default [sqlite3_vfs] object is used.
3863 ** <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
3865 ** be used to access the database file on disk. ^If this option is set to
3866 ** an empty string the default VFS object is used. ^Specifying an unknown
3867 ** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is
3882 ** or writes from disk is used. ^It is an error to specify a value for
3891 ** ^If sqlite3_open_v2() is used and the "cache" parameter is present in
3939 ** necessary - space characters can be used literally
3962 ** <b>Note to Windows users:</b> The encoding used for the filename argument
4150 ** used again after sqlite3_free_filename(Y) has been called. This means
4328 ** used to implement an SQL statement. If [sqlite3_prepare_v2()] or
4383 ** be used just once or at most a few times and then destroyed using
4390 ** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
4419 ** [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used
4474 ** always used to do, [sqlite3_step()] will automatically recompile the SQL
4557 ** SQL text used to create [prepared statement] P if P was
4565 ** semantics used to normalize a SQL statement are unspecified and subject
4673 ** This interface can be used in combination [sqlite3_next_stmt()]
4675 ** connection that are in need of being reset. This can be used,
4695 ** [sqlite3_value_dup()] interface can be used to construct a new
4706 ** sqlite3_value objects and they can be used interchangeably. However,
4717 ** Unprotected sqlite3_value objects may only be used as arguments
4768 ** SQL parameter is used more than once, second and subsequent
4899 ** ^This routine can be used to find the number of [SQL parameters]
4907 ** number of unique parameters. If parameters of the ?NNN form are used,
5095 ** used to hold those values.
5153 ** be the case that the same database connection is being used by two or
5167 ** can be used to restore the legacy behavior.
5224 ** Note that the SQLITE_TEXT constant was also used in SQLite version 2
5292 ** is used to extract the value) then an automatic type conversion is performed.
5298 ** The return value of sqlite3_column_type() can be used to decide which
5299 ** of the first six interface should be used to extract the column value.
5308 ** or sqlite3_column_bytes16() interfaces can be used to determine the size
5345 ** an unprotected sqlite3_value object may only be used safely with
5348 ** [sqlite3_column_value()] is used in any other way, including calls
5358 ** is requested, [sqlite3_snprintf()] is used internally to perform the
5428 ** [sqlite3_finalize()] is called. ^The memory space used to hold strings
5525 ** are used to add SQL functions or aggregates or to redefine the behavior
5560 ** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8]
5582 ** used inside of triggers, view, CHECK constraints, or other elements of
5608 ** non-NULL, in which case the new function may be used as either an aggregate
5626 ** SQL function is used. ^A function implementation with a non-negative
5713 ** be deterministic in order to be used in certain contexts such as
5721 ** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in
5826 ** are used to pass parameter information into the functions that
5950 ** information can be used to pass a limited amount of context from
6050 ** These functions may be used by (non-aggregate) SQL functions to
6129 ** These routines are used by the xFunc or xFinal callbacks that
6135 ** functions used to bind values to host parameters in prepared statements.
6253 ** ^A [protected sqlite3_value] object may always be used where an
6255 ** kind of [sqlite3_value] object can be used with this interface.
6370 ** collating function is registered and used, then the behavior of SQLite
6419 ** can be used, a single callback function may be registered with the
6425 ** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
6538 ** if a [database connection] is being used at the same time in a separate
6595 ** if a [database connection] is being used at the same time in a separate
6618 ** [sqlite3_win32_set_directory] interface is used to set the value associated
6623 ** prior to being used. The [sqlite3_win32_set_directory] interface returns
6681 ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
6724 ** will be an absolute pathname, even if the filename used
6728 ** can be used as the filename input parameter to these routines:
7018 ** must be used, it is recommended that shared cache only be enabled for
7039 ** held by the database library. Memory used to cache database
7165 ** for the table using the same algorithm used by the database engine to
7260 ** [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method be used to enable only this
7370 ** Structures used by the virtual table interface
7435 ** The sqlite3_index_info structure and its substructures is used as part
7489 ** ^[sqlite3_free()] is used to free idxPtr if and only if
7523 ** used with an SQLite version earlier than 3.8.2, the results of attempting
7526 ** therefore only be used if [sqlite3_libversion_number()] returns a
7529 ** It may therefore only be used if
7552 int idxNum; /* Number used to identify the index */
7562 sqlite3_uint64 colUsed; /* Input: Mask of columns used by statement */
7588 ** used.
7606 ** The collating sequence to be used for comparison can be found using
7634 ** ^These routines are used to register a new [virtual table module] name.
7724 ** [virtual table] and are used
7727 ** by the [sqlite3_module.xClose | xClose] method. Cursors are used
7788 ** can be used to read or write small subsections of the BLOB.
7866 ** and the built-in [zeroblob] SQL function may be used to create a
7890 ** ^This function is used to move an existing [BLOB handle] so that it points
7954 ** ^(This function is used to read data from an open [BLOB handle] into a
7983 ** ^(This function is used to write data into an open [BLOB handle] from a
8113 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
8124 ** used by the current version of SQLite. Future versions of SQLite
8131 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
8178 ** used to allocate and use mutexes.
8186 ** Additionally, an instance of this structure can be used as an
8340 ** ^A NULL pointer can be used in place of "main" to refer to the
8375 ** ^The sqlite3_test_control() interface is used to read out internal
8394 ** These constants are the valid operation code parameters used
8459 ** The parser used by SQLite is forgiving. It is often possible to use
8465 ** using keywords as identifiers. Common techniques used to avoid keyword
8570 ** ^This method can be used, for example, to add whitespace indentation.
8608 ** [sqlite3_str] object. Applications must not used the pointer returned
8622 ** ^These interfaces are used to retrieve runtime status information
8683 ** <dd>This parameter returns the number of pages used out of the
8705 ** <dd>No longer used.</dd>
8708 ** <dd>No longer used.</dd>
8711 ** <dd>No longer used.</dd>
8736 ** ^This interface is used to retrieve runtime status information
8798 ** memory used by all pager caches associated with the database connection.)^
8805 ** memory used by that pager cache is divided evenly between the attached
8815 ** memory used to store the schema for all databases associated
8817 ** ^The full amount of memory used by the schemas is reported, even if the
8824 ** and lookaside memory used by all prepared statements associated with
8857 ** additional overhead. This parameter can be used help identify
8891 ** be used to monitor the performance characteristics of the prepared
8897 ** ^(This interface is used to retrieve and reset counter values from
8941 ** used as a proxy for the total work done by the prepared statement.
8969 ** used to store the prepared statement. ^This value is not actually
9022 ** SQLite is used for the page cache.
9026 ** that memory is allocated and released, and the policies used to
9047 ** built-in default page cache is used instead of the application defined
9052 ** It can be used to clean up
9078 ** created will be used to cache database pages of a file stored on disk, or
9079 ** false if it is used for an in-memory database. The cache implementation
9104 ** pointer to a buffer of szPage bytes used to store the content of a
9148 ** The xRekey() method is used to change the key value associated with the
9161 ** ^The xDestroy() method is used to delete a cache allocated by xCreate().
9193 ** by sqlite3_pcache_methods2. This object is not used by SQLite. It is
9280 ** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and
9315 ** is being used to write to the source database when sqlite3_backup_step()
9335 ** used by the backup operation, then the backup will be automatically
9337 ** database is modified by the using the same database connection as is used
9351 ** and may not be used following a call to sqlite3_backup_finish().
9381 ** ^The source [database connection] may be used by the application for other
9384 ** connections, then the source database connection may be used concurrently
9397 ** guarantee that the shared cache used by the destination database
9429 ** ^This API may be used to register a callback that SQLite will invoke
9559 ** ^The definition of [GLOB] pattern matching used in
9576 ** ^The definition of [LIKE] pattern matching used in
9600 ** used with [sqlite3_snprintf()] to generate the final output string.
9621 ** ^The [sqlite3_wal_hook()] function is used to register a callback that
9675 ** ^The [wal_autocheckpoint pragma] can be used to invoke this interface
9702 ** This interface used to be the only way to cause a checkpoint to
9800 ** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface
9841 ** is used.
9891 ** prohibits that virtual table from being used from within triggers and
10009 ** This API may only be used from within an [xBestIndex|xBestIndex method]
10032 ** "aOrderBy" field are adjacent.)^ This mode is used when the query planner
10045 ** This mode is used for a DISTINCT query.
10051 ** it is not required to omit any rows. This mode is used for queries
10081 ** This interface may only be used from within an
10204 ** This API may only be used from within the [xBestIndex|xBestIndex method]
10250 ** Note that the [SQLITE_IGNORE] constant is also used as a potential
10255 /* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */
10264 ** The following constants can be used for the T parameter to the
10292 ** used for the X-th loop.
10323 ** Since this interface is expected to be rarely used, it is only
10334 ** zero or greater than or equal to the total number of loops used to implement
10457 ** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE
10458 ** preupdate callbacks; if it is used by an SQLITE_INSERT callback then the
10466 ** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE
10467 ** preupdate callbacks; if it is used by an SQLITE_DELETE callback then the
10477 ** When the [sqlite3_blob_write()] API is used to update a blob column,
10587 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10636 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10653 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
10661 ** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages
10827 ** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used.
10876 /* The double-precision datatype used by RTree depends on the
10886 ** Register a geometry callback named zGeom that can be used as part of an
10913 ** used as part of an R-Tree geometry query as follows:
10986 ** An instance of this object is a [session] that can be used to
11025 ** The session object will be used to create changesets for tables in
11055 ** This method is used to configure a session object after it has been
11065 ** This option is used to set, clear or query the flag that enables
11097 ** no-op, and may be used to query the current state of the session.
11122 ** This function is used to set, clear or query the session object indirect
11126 ** of the indirect flag, and may be used to query the current state of the
11370 ** used to update the table in database zFrom (call this the "from-table")
11421 ** A patchset blob may be used with up to date versions of all
11461 ** CAPI3REF: Query for the amount of heap memory used by a session object.
11464 ** used by the session object passed as the only argument.
11472 ** Create an iterator used to iterate through the contents of a changeset.
11477 ** The following functions can be used to advance and query a changeset
11539 ** This function may only be used with iterators created by the function
11611 ** This function is used to find which columns comprise the PRIMARY KEY of
11701 ** This function should only be used with iterator objects passed to a
11746 ** This function is used to finalize an iterator allocated with
11777 ** This function is used to "invert" a changeset object. Applying an inverted
11810 ** This function is used to concatenate two changesets, A and B, into a
11846 ** A changegroup is an object used to combine two or more
11855 ** An sqlite3_changegroup object is used to combine two or more changesets
12136 ** This can be used to further customize the application's conflict
12147 ** may set (*ppRebase) to point to a "rebase" that may be used with the
12646 ** The sqlite3session_config() interface is used to make global configuration
12664 ** and output data in approximately 1 KiB chunks. This operand may be used
12667 ** If this value is greater than 0, it is used as the new streaming data
12779 ** This function may be quite inefficient if used with an FTS5 table
12802 ** This API can be quite slow if used with an FTS5 table created with the
12818 ** This API can be quite slow if used with an FTS5 table created with the
12828 ** This API function is used to query the FTS table for phrase iPhrase
12838 ** function may be used to access the properties of each matched row.
12890 ** This function is used to retrieve the total number of rows in the table.
12896 ** This function is used, along with type Fts5PhraseIter and the xPhraseNext
12913 ** modify this structure directly - it should only be used as shown above
12917 ** This API can be quite slow if used with an FTS5 table created with the
12930 ** APIs are used to iterate through the set of columns in the current row
12942 ** This API can be quite slow if used with an FTS5 table created with the
12951 ** significantly more efficient than those alternatives when used with
13009 ** This function is used to allocate and initialize a tokenizer instance.
13017 ** tokenizer name as part of the CREATE VIRTUAL TABLE statement used
13340 ** It used to be the case that setting this value to zero would
13508 #pragma warn -aus /* Assigned value is never used */
13541 ** The following macros are used to cast pointers to integers and
13609 ** Older versions of SQLite used an optional THREADSAFE macro.
13719 ** The testcase() macro is used to aid in coverage testing. When
13725 ** can be used to make sure boundary values are tested. For
13726 ** bitmask tests, testcase() can be used to make sure each bit
13727 ** is significant and used at least once. On switch statements
13741 ** The TESTONLY macro is used to enclose variable declarations or
13755 ** used to contain that setup code. The "VVA" acronym stands for
13818 ** during a normal build. The following macro can be used to disable tests
13830 ** Declarations used for tracing the operating system interfaces.
13871 ** to fit in 32-bits. This macro is used inside of various testcase()
13880 ** in theory, be used by the compiler to generate better code, but
13900 ** used in SQLite.
13944 ** be opaque because it is used by macros.
14184 ** This allows better measurements of where memcpy() is used when running
14186 ** should not be used in production. This is a performance measurement
14217 ** to omit code used by TEMP tables without messy #ifndef statements.
14276 ** of -1024*N bytes is allocated and used for as many pages as it will hold.
14396 ** The datatype used to store estimates of the number of rows in a
14399 ** can be used at compile-time if desired.
14408 ** Estimated quantities used for query planning are stored as 16-bit
14520 ** Round up a number to the next larger multiple of 8. This is used
14543 ** macro is used only within assert() to verify that the code gets
14565 ** Default maximum size of memory used by memory-mapped I/O in the VFS
14630 ** An instance of the following structure is used to store the busy-handler
14648 ** The PREFERRED names are used whereever possible. But LEGACY is also
14649 ** used for backwards compatibility.
14706 ** macro is used for this purpose. And instead of referencing the variable
14727 ** The following macros are used to suppress compiler warnings and to
14735 ** When a function parameter is not used at all within the body of a function,
14737 ** However, these macros may also be used to suppress warnings related to
14738 ** parameters that may or may not be used depending on compilation options.
14739 ** For example those parameters only used in assert() statements. In these
14808 ** The bitmask datatype defined below is used for various optimizations.
15002 ** 2006-10-31: The default prefix used to be "sqlite_". But then
15061 ** are used, the lock is placed on the same range of bytes that is used
15067 ** The following #defines specify the range of bytes used for locking.
15073 ** byte ranges are used for Unix. This leaves open the possibility of having
15076 ** tool is being used for file sharing) implements locks correctly between
15081 ** actual data in the bytes used for locking. The pager never allocates
15197 ** The type used to represent a page number. The first page in a file
15198 ** is called page 1. 0 is used to represent "not a page".
15213 ** Page number PAGER_SJ_PGNO is never used in an SQLite database (it is
15215 ** used in the journal to signify that the remainder of the journal file
15296 /* Functions used to configure a Pager object. */
15316 /* Functions used to obtain and release page references. */
15332 /* Functions used to manage pager transactions and savepoints. */
15375 /* Functions used to query pager state and configuration. */
15393 /* Functions used to truncate the database file. */
15539 ** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With
15541 ** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL
15607 ** Note that BTREE_HINT_FLAGS with BTREE_BULKLOAD is the only hint used by
15624 ** be used only for equality key searches.
15636 ** only be used by SQLite for the following:
15640 ** * to read values that will be used to create keys that other
15643 ** The BTREE_FORDELETE flag is an optimization hint. It is not used by
15696 ** Index btrees (used for indexes and also WITHOUT ROWID tables) contain
15702 ** Table btrees (used for rowid tables) contain an integer rowid used as
15714 ** pData data not used
15715 ** aMem not used decomposed key value
15716 ** nMem not used entries in aMem
15717 ** nData length of pData not used
15718 ** nZero extra zeros after pData not used
15720 ** This object is used to pass information into sqlite3BtreeInsert(). The
15721 ** same information used to be passed as five separate parameters. But placing
15819 /* These routines are used inside assert() statements only. */
15924 ** A sub-routine used to implement a trigger program.
15932 void *token; /* id that may be used to recursive triggers */
15937 ** A smaller version of VdbeOp used for the VdbeAddOpList() function because
15951 #define P4_NOTUSED 0 /* The P4 parameter is not used */
16005 ** header file that defines a number for each opcode used by the VDBE.
16399 ** The VdbeCoverage macros are used to set a coverage testing point
16648 /* Try to return memory used by the pcache module to the main memory heap */
16750 /* The SQLITE_EXTRA_DURABLE compile-time option used to set the default
16771 ** In other words, the zero-based numbers are used for all external interfaces
16772 ** and the one-based values are used internally.
16785 ** aDb[1] is the database file used to hold temporary tables. Additional
16820 Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */
16822 u8 enc; /* Text encoding used by this database */
16828 ** These macros can be used to test, set, or clear bits in the
16857 ** Lookaside malloc is a set of fixed-size buffers that can be used
16874 ** lookaside allocations are not used to construct the schema objects.
16883 ** used and freed, they are added back to the pFree list. New allocations
16908 LookasideSlot *pInit; /* List of buffers not previously used */
16911 LookasideSlot *pSmallInit; /* List of small buffers not prediously used */
16951 ** Information held in the "sqlite3" database connection object and used
16958 char *zAuthPW; /* Password used to authenticate */
16959 char *zAuthUser; /* User name used to authenticate */
16968 /* Functions used only by user authorization logic */
17047 struct sqlite3InitInfo { /* Information used during initialization */
17132 ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
17218 /* Flags used only if debugging */
17240 ** Bits of the sqlite3.dbOptFlags field that are used by the
17304 ** The u.pHash field is used by the global built-ins. The u.pDestructor
17305 ** field is used by per-connection app-def functions.
17396 ** used to create the initializers for the FuncDef structures.
17429 ** to a NULL pointer. The bNC parameter is not used.
17438 ** arbitrary non-NULL pointer. The bNC parameter is not used.
17527 ** The following are used as the second parameter to sqlite3Savepoint(),
17649 ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
17655 ** used as the P4 operand, they will be more readable.
17695 ** instance of the sqlite3_vtab* handle used to access the virtual table
17701 ** then be used by the virtual table implementation to access real tables
17704 ** connection as that used to execute SQL operations on the virtual table.
17757 /* ... also used as column name list in a VIEW */
17945 ** The following symbolic values are used to record which type
17964 ** argument to sqlite3VdbeKeyCompare and is used to control the
17992 ** Records are used to store the content of a table row and to store
18029 int n; /* Cache of aMem[0].n used by vdbeRecordCompareString() */
18065 ** The colNotIdxed bitmask is used in combination with SrcItem.colUsed
18072 ** table is used, the "colUsed & colNotIdxed" test will always be non-zero
18081 ** used to store the address of a VDBE instruction, not a database page
18087 i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */
18166 ** this structure. Tokens are also used as part of an expression.
18202 struct AggInfo_col { /* For each column used in source tables */
18210 int nColumn; /* Number of used entries in aCol[] */
18212 ** Additional columns are used only as parameters to
18218 int iDistinct; /* Ephemeral table used to enforce DISTINCT */
18262 ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
18271 ** expression is used as a result in an aggregate SELECT, then the
18362 int regReturn; /* Register used to hold return address */
18411 /* Macros can be used to test, set, or clear bits in the
18421 /* Macros used to ensure that the correct members of unions are accessed
18437 /* The ExprSetVVAProperty() macro is used for Verification, Validation,
18480 ** name. An expr/name combination can be used in several ways, such
18483 ** also be used as the argument to a function, in which case the a.zName
18484 ** field is not used.
18487 ** is used for multiple purposes:
18494 ** ENAME_TAB DB.TABLE.NAME used to resolve names
18513 unsigned bUsed :1; /* This column used in a SF_NestedFrom subquery */
18544 ** The IdList.a.idx field is used when the IdList represents the list of
18581 ** contains more than 63 columns and the 64-th or later column is used.
18596 Select *pSelect; /* A SELECT statement used in place of a table name */
18617 int iCursor; /* The VDBE cursor number used to access this table */
18622 Bitmask colUsed; /* Bit N set if column N used. Details above for N>62 */
18645 ** is used to hold the FROM clause of a SELECT statement. SrcList also
18690 /* 0x2000 not currently used */
18692 /* 0x8000 not currently used */
18696 #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */
18724 SrcList *pSrcList; /* One or more tables used to resolve names */
18756 #define NC_UEList 0x000080 /* True if uNC.pEList is used */
18757 #define NC_UAggInfo 0x000100 /* True if uNC.pAggInfo is used */
18758 #define NC_UUpsert 0x000200 /* True if uNC.pUpsert is used */
18759 #define NC_UBaseReg 0x000400 /* True if uNC.iBaseReg is used */
18777 ** WHERE clause used to identify partial unique indexes.
18795 ** when the Upsert is destroyed. The fields below are used to transfer
18838 Expr *pLimit; /* LIMIT expression. NULL means not used. */
18901 ** SRT_Discard Throw the results away. This is used by SELECT
18952 ** column returned by the SELECT is used as the integer
18988 int iSDParm; /* A parameter used by the eDest disposal method */
18992 char *zAffSdst; /* Affinity used for SRT_Set, SRT_Table, and similar */
19028 ** a mask of new.* columns used by the program.
19075 const char *zIdxName; /* Name of index, used only for bytecode comments */
19100 ** The nTableLock and aTableLock variables are only used if the shared-cache
19102 ** used to store the set of table-locks required by the statement being
19103 ** compiled. Function sqlite3TableLock() is used to add entries to the
19129 int nMem; /* Number of memory cells used so far */
19133 int nLabel; /* The *negative* of the number of labels used */
19137 IndexedExpr *pIdxExpr;/* List of expressions used by active indexes */
19169 ** initialized as they will be set before being used. The boundary is
19201 ** Also used to hold redundant UNIQUE constraints
19253 ** An instance of the following structure can be declared on a stack and used
19274 /* Also used in P2 (not P5) of OP_Delete */
19282 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
19283 #define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */
19284 #define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */
19335 ** An instance of struct TriggerStep is used to store a single SQL statement
19408 ** An objected used to accumulate the text of a string where we
19428 ** A pointer to this structure is used to communicate information
19453 ** be used on trunk check-ins. They are a temporary mechanism available
19505 sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */
19537 ** This macro is used inside of assert() statements to indicate that
19586 ** The following structure contains information used by the sqliteFix...
19596 const char *zType; /* Type of the container - used for error messages */
19597 const Token *pName; /* Name of the container - used for error messages */
19684 ** An instance of the TreeView object is used for printing the content of
19694 ** This object is used in various ways, most (but not all) related to window
19700 ** plus additional fields used during code generation.
19711 ** TK_FILTER. In this case the only field used is Window.pFilter.
19735 int csrApp; /* Function cursor (used by min/max) */
19736 int regApp; /* Function register (also used by min/max) */
19951 /* Access to mutexes used by sqlite3_status() */
19977 int nUsed; /* Number of arguments used so far */
20440 ** Routines to read and write variable-length integers. These used to
20834 ** The interface to the code in fault.c used for identifying "benign"
20858 #define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
20859 #define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
20903 ** sqlite3IoTrace is a pointer to a printf-like routine used to
20917 ** only. They are used to verify that different "types" of memory
20941 ** play when the SQLITE_MEMDEBUG compile-time option is used.
21053 ** processor and returns that value. This can be used for high-res
21108 ** sqlite3Hwtime() is only used for some obscure debugging
21135 ** is used for testing the I/O recovery logic.
21210 ** This file implements routines used to report what compile-time options
22076 ** The following 256 byte lookup table is used to support SQLites built-in
22096 ** array. tolower() is used more often than toupper() by SQLite.
22098 ** Bit 0x40 is set if the character is non-alphanumeric and can be used in an
22299 ** Counter used for coverage testing. Does not come into play for
22311 ** The following performance counter can be used in place of
22327 ** than 1 GiB. The sqlite3_test_control() interface can be used to
22421 ** VDBE. This information used to all be at the top of the single
22461 /* Opaque type used by code in vdbesort.c */
22536 u64 maskUsed; /* Mask of columns used by this cursor */
22585 u8 *aOnce; /* Bitmask used by OP_Once */
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 */
22767 ** instance of this structure is the first argument to the routines used
22781 Mem *pMem; /* Memory cell used to store aggregate context */
22832 Parse *pParse; /* Parsing context used to create this Vdbe */
22861 i64 startTime; /* Time when query started - used for profiling */
22880 u32 aCounter[9]; /* Counters used by sqlite3_stmt_status() */
22891 SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
22916 ** Structure used to store the context required by the
22937 ** An instance of this object is used to pass an vector of values into
23359 ** Return an approximation for the amount of memory currently used
23386 ** *pCurrent gets an accurate estimate of the amount of memory used
23432 ** *pCurrent gets an accurate estimate of the amount of memory used
23535 ** The Gregorian calendar system is used for all dates and times,
24015 ** library function localtime_r() is used to assist in the calculation of
24131 float rXform; /* Constant used for this transform */
24884 ** is used for testing the I/O recovery logic.
25426 ** used when no other memory allocator is specified using compile-time
25484 ** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The
25513 ** used when no other memory allocator is specified using compile-time
25539 ** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined.
25784 ** This version of the memory allocator is used only if the
25836 ** All of the static variables used by this module are collected
25974 ** Fill a buffer with pseudo-random bytes. This is used to preset
26385 ** All of the static variables used by this module are collected
27034 ** This version of the memory allocator is used only when
27055 ** mem5.szAtom is always at least 8 and 32-bit integers are used,
27061 ** Masks used for mem5.aCtrl[] elements.
27067 ** All of the static variables used by this module are collected
27326 ** not used after being freed */
27609 ** This type of mutex is used as the database handle mutex when testing
27614 ** Type for all mutexes used when SQLITE_ENABLE_MULTITHREADED_CHECKS
27631 ** Pointer to real mutex methods object used by the CheckMutex
28140 ** is used regardless of the run-time threadsafety setting.
28167 ** The code in this file is only used if we are compiling threadsafe
28281 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
28291 ** used by the current version of SQLite. Future versions of SQLite
28298 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
28668 ** The code in this file is only used if we are compiling multithreaded
28687 ** These are the initializer values used when declaring a "static" mutex
28759 ** "interlocked" magic used here is probably not strictly necessary.
28829 ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
28839 ** used by the current version of SQLite. Future versions of SQLite
28846 ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
28954 ** The sqlite3_mutex_try() routine is very rarely used, and when it
28955 ** is used it is merely an optimization. So it is OK for it to always
29054 ** Memory allocation functions used throughout sqlite.
29061 ** held by SQLite. An example of non-essential memory is memory used to
29109 ** Deprecated external interface. It used to set an alarm callback
29114 void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
29127 ** zero disables the limit. A negative argument is a no-op used to
29168 ** disables the hard heap limit. A negative argument is a no-op used
29218 ** words if the amount of heap used is close to the limit set by
29317 ** This is not a limit on the total amount of memory used. This is
30007 ** most frequently used conversion types first.
30047 /* Floating point constants used for rounding */
30179 char *zExtra = 0; /* Malloced memory used by some conversion */
31114 ** memory is used if not NULL. db->mallocFailed is set appropriately
31528 sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
32221 if( pList->a[i].fg.bUsed ) fprintf(stdout, "(used) ");
32591 ** parameters. These variants are intended to be used from a symbolic
32639 ** Random numbers are used by some of the database backends in order
32845 /* This routine is never used in single-threaded mode */
33073 ** This file contains routines used to translate between UTF-8,
33103 ** The following constant value is used by the SQLITE_BIGENDIAN and
33110 ** This lookup table is used to help decode the first byte of
33239 ** This routine transforms the internal text encoding used by pMem to
33493 /* This test function is not currently used by the automated test-suite.
33611 ** Utility functions used throughout sqlite.
33624 ** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
33780 ** This function should be used to report any error that occurs while
33784 ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
34049 int eValid = 1; /* True exponent is either not used or is well-formed */
34587 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
34808 /* A 32-bit varint is used to store size information in btrees.
34974 ** not have been used. The "type" of connection pointer is given as the
34996 ** used as an argument to sqlite3_errmsg() or sqlite3_close().
35223 ** VList. The second integer is the number of integers actually used.
35236 ** int nUsed; // Number of used slots
35239 ** int nSlot; // Slots used by this entry
35250 sqlite3 *db, /* The database connection used for malloc() */
35330 ** used in SQLite.
35819 /* SQLITE_KV_TRACE() is used for tracing calls to kvstorage routines. */
35826 /* SQLITE_KV_LOG() is used for tracing calls to the VFS interface */
35835 ** Forward declaration of objects used by this VFS implementation
36118 ** Encode binary into the text encoded used to persist on disk.
36800 ** * Unique file ID logic used by VxWorks.
36817 #if SQLITE_OS_UNIX /* This file is used on unix only */
36820 ** There are various methods for file locking used for concurrency
36975 ** structure are used to store the file descriptor while waiting for an
37024 /* The next group of variables are used to track whether or not the
37120 ** Linux-specific IOCTL magic numbers used for controlling F2FS
37388 sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
37466 ** opening database file using file descriptors that are commonly used for
37532 ** global mutex is used to protect the unixInodeInfo and
37533 ** vxworksFileId objects used by this file, all of which may be
37536 ** Function unixMutexHeld() is used to assert() that the global mutex
37537 ** is held when required. This function is only used as part of assert()
37593 ** This routine is used for troubleshooting locks on multithreaded
37713 ** A pointer to an instance of the following structure can be used as a
37922 ** threading library is being used. So there is no way to know at
37927 ** SQLite used to support LinuxThreads. But support for LinuxThreads
37935 ** An instance of the following structure serves as the key used
38010 ** This routine is used only within assert() to help verify correct mutex
38180 unixFile *pFile, /* Unix file with file desc used in the key */
38191 /* Get low-level information about the file that we can used to
38516 ** This property is used by the algorithm for rolling back a journal file
38709 ** Add the file descriptor used by file handle pFile to the corresponding
38996 ** also be used if the application employs some external mechanism to
38999 ** corruption if this locking mode is used in situations where multiple
40403 ** Count the number of fullsyncs and normal syncs. This is used to test
40475 ** FULLSYNC. This is used during testing to verify that this procedure
40536 ** The directory file descriptor is used for only one thing - to
40763 ** This is a similar technique to that used by glibc on systems
41141 ** Object used to represent an shared memory buffer.
41190 ** Structure used internally by this VFS to record the state of an
41212 ** Constants used for locking
41448 ** The file used to implement shared-memory is in the same directory
41456 ** from the database file is used, then differing access permissions
41484 char *zShm; /* Name of the file used for SHM */
41759 ** is to be used in an assert(). e.g.
42242 ** of "finder" functions. A finder-function is used to locate the appropriate
42259 ** A pointer to the F pointer is used as the pAppData value for VFS
42486 ** locking works. If it does, then that is what is used. If it does not
42792 ** Implementation in the proxy-lock division, but used by unixOpen()
42899 ** original filename is unavailable. But 8_3_NAMES is only used for
42928 ** used by the test_multiplex.c module.
42964 ** Previously, the SQLite OS layer used three functions in place of this
43102 ** they may be stored as part of the file handle and used by the
43324 ** two of them are actually used */
43650 ** the number of seconds since 1970 and is used to set the result of
43715 ** used.
43791 ** host ID in it, the proxy path in the conch file will be used, otherwise
43793 ** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
43830 ** The proxy file - a single-byte file used for all advisory file locks
43843 ** to be created the first time they are used.
43862 ** Overrides the default directory used for lock proxy files that
43868 ** lock proxy files, only used when LOCKPROXYDIR is not set.
43873 ** force proxy locking to be used for every database file opened, and 0
44268 ** lockPath means that the lockPath in the conch file will be used if the
44933 ** should not be used.
45089 #if SQLITE_OS_WIN /* This file is used for Windows only */
45245 ** This macro is used when a local variable is set to a value that is
45246 ** [sometimes] not used by the code (e.g. via conditional compilation).
45253 ** Returns the character that should be used as the directory separator.
45313 /* Forward references to structures used for WAL */
45338 sqlite3_vfs *pVfs; /* The VFS used to open this file */
45341 short sharedLockByte; /* Randomly chosen byte used as a shared lock */
45351 HANDLE hMutex; /* Mutex used to control access to shared lock */
45352 HANDLE hShared; /* Shared memory segment used for locking */
45366 ** The winVfsAppData structure is used for the pAppData member for all of the
45384 * The size of the buffer used by sqlite3_win32_write_debug().
45398 * allocator subsystem; otherwise, the default process heap will be used. This
45442 * This is cache size used in the calculation of the initial size of the
46240 sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
46321 ** "pnLargest" argument, if non-zero, will be used to return the size of the
46485 ** this routine is used to determine if the host is Win95/98/ME or
47198 ** The "winIoerrCanRetry1" macro is used to determine if a particular I/O
47208 ** may be used to include additional error codes in the set that should
47321 ** Create the mutex and shared memory used for locking in the file
47721 /* Forward references to VFS helper methods used for memory mapped files */
48061 ** Count the number of fullsyncs and normal syncs. This is used to test
48210 ** Historically, SQLite has used both the LockFile and LockFileEx functions.
48211 ** When the LockFile function was used, it was always expected to fail
48213 ** obtain an exclusive lock. These flags are used with the LockFileEx function
48537 ** also be used if the application employs some external mechanism to
48540 ** corruption if this locking mode is used in situations where multiple
48582 /* Forward references to VFS helper methods used for temporary files */
48752 ** global mutex is used to protect the winLockInfo objects used by
48755 ** Function winShmMutexHeld() is used to assert() that the global mutex
48756 ** is held when required. This function is only used as part of assert()
48777 ** Object used to represent a single file opened and mmapped to provide
48831 ** Structure used internally by this VFS to record the state of an
48855 ** Constants used for locking
49018 /* Look to see if there is an existing winShmNode that can be used.
49927 ** be used. However, we may need to convert the string containing
50019 ** If not, return SQLITE_ERROR. The number 17 is used here in order to
50020 ** account for the space used by the 15 character random suffix and the
50077 sqlite3_vfs *pVfs, /* Not used on win32 */
50213 /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
50248 ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
50410 sqlite3_vfs *pVfs, /* Not used on win32 */
50412 int syncDir /* Not used on win32 */
50518 sqlite3_vfs *pVfs, /* Not used on win32 */
50613 ** Returns non-zero if the specified path name should be used verbatim. If
51008 ** the number of seconds since 1970 and is used to set the result of
51294 ** Forward declaration of objects used by this utility
51308 ** used by more than one database connection. Mutexes are used by shared
51384 /* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */
51386 /* static int memdbSectorSize(sqlite3_file*); // not used */
51599 ** support WAL mode) the truncate() method is only used to reduce
51722 ** This interface is only used for crash recovery, which does not
51760 #if 0 /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */
51892 #if 0 /* Only used to delete rollback journals, super-journals, and WAL
51893 ** files, none of which exist in memdb. So this routine is never used */
51985 #if 0 /* Never used. Modern cores only call xCurrentTimeInt64() */
52210 ** A bitmap is used to record which pages of a database file have been
52470 ** Destroy a bitmap object. Reclaim all memory used.
52495 ** Then the following macros can be used to set, clear, or test
52523 ** Opcode 5 is used to deliberately induce a fault in order to
52641 ** The PCache.pSynced variable is used to optimize searching for a dirty
52859 ** being used for an in-memory database, this function is a no-op.
52898 ** built-in default page cache is used instead of the application defined
53071 "spill page %d making room for %d - cache used: %d/%d",
53522 ** callback. This is only used if the SQLITE_CHECK_PAGES macro is
53562 ** as the database page number and how that database page is used. PgHdr
53563 ** is added by the pcache.c layer and contains information used to keep track
53576 ** Historical note: It used to be that if the SQLITE_PCACHE_SEPARATE_HEADER
53606 ** sqlite3Malloc() call and that memory is used for the first N pages allocated.
53607 ** Or if N is negative, then -1024*N bytes of memory are allocated and used
53610 ** Only one of (2) or (3) can be used. Once the memory available to (2) or
53614 ** Earlier versions of SQLite used only methods (1) and (2). But experiments
53628 ** directly before this structure and is used to cache the page content.
53726 unsigned int nPurgeableDummy; /* pnPurgeable points here when not used*/
53736 void *pBulk; /* Bulk memory used by pcache-local */
53740 ** Free slots in the allocator used to divide up the global page cache
53748 ** Global data used by this cache.
53778 ** alias "pcache1". This ensures that the WSD emulation is used when
53870 ** Malloc function used within this file to allocate space from the buffer
54021 ** Malloc function used by SQLite to obtain space from the buffer configured
54043 ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
54049 ** Or, the heap is used for all page cache memory but the heap is
54066 ** This function is used to resize the hash table used by the cache passed
54106 ** This function is used internally to remove the page pPage from the
54240 ** PGroup in pcache1.grp is used for all page caches (mode-2).
54487 ** For a non-purgeable cache (a cache used as the storage for an in-memory
54753 ** Return the global mutex used by this PCACHE implementation. The
54794 ** This function is used by test procedures to inspect the internal state
54877 ** TEST and SMALLEST may not be used by the same RowSet. This used to
54878 ** be possible, but the feature was not used, so it was removed in order
55221 ** been used. Older versions of RowSet allowed that, but as the
55222 ** capability was not used by the code generator, it was removed
55227 assert( p->pForest==0 ); /* Cannot be used with sqlite3RowSetText() */
55336 ** The pager is used to access a database disk file. It implements
55554 ** (6) If a super-journal file is used, then all writes to the database file
55605 ** The following two macros are used within the PAGERTRACE() macros above
55891 ** A macro used for invoking the codec if there is one
55906 ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
55972 ** This boolean variable is used to make sure that the change-counter
56036 ** sub-journals are only used for in-memory pager files.
56063 ** variable at the start of the transaction. It is used during rollback,
56078 ** dbFileSize is not used when rolling back a transaction. In this case
56085 ** The dbHintSize variable is used to limit the number of calls made to
56097 ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
56105 ** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode
56106 ** and contains the flags used to sync the checkpoint operations in the
56107 ** lower two bits, and sync flags used for transaction commits in the WAL
56201 Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
56217 ** The following global variables hold counters used for
56234 ** was obtained from /dev/random. It is used only as a sanity check.
56489 ** is intended to be used within debuggers. For example, as an alternative
56548 ** Set the Pager.xGet method for the appropriate routine used to fetch
56687 ** atomic-batch-write optimizations can be used with this pager. The
56688 ** atomic-write optimization can be used if:
56695 ** If it can be used, then the value returned is the size of the journal
56698 ** The atomic-batch-write optimization can be used if OsDeviceCharacteristics()
56702 ** If neither optimization can be used, 0 is returned.
56743 ** on the cache using a hash function. This is used for testing
56789 ** used to store a super-journal file name at the end of a journal file.
56941 ** - 4 bytes: Random number used for page hash.
56943 ** - 4 bytes: Sector size used by the process that wrote this journal.
56950 char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
57031 ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
57158 /* Update the assumed sector-size to match the value used by
57502 ** the journal file is never used. Instead, if the journalMode is
57504 ** journalMode==PERSIST is used instead.
57691 ** Changing the formula used to compute this checksum results in an
57786 u32 cksum; /* Checksum used for sanity checking */
57798 assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
57799 assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
57983 /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But
58146 ** This function is used to change the actual size of the database
58216 ** of the open database file. The sector size will be used
58288 ** from the file size. This value is used when the user selects the
58751 ** This routine used to be called "pagerOpenSnapshot()" because it essentially
58905 ** implementation below). This is used to ensure that a page is only
59161 ** attempts to open a temporary file. This information is used for
59237 ** Change the page size used by the Pager object. The new page size
59330 ** entire content of a database page. This buffer is used internally
59359 ** The following set of routines are used to disable the simulated
59360 ** I/O error mechanism. These routines are used to avoid simulated
59363 ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
59389 ** function is used to read database headers, and a new transient or
59824 ** problematic header will occur, if it exists. aMagic is used
60218 ** and used as the file to be cached. Temporary files are be deleted
60221 ** This can be used to implement an in-memory database.
60227 ** (The extra space is used by btree as the MemPage object.)
60229 ** The flags argument is used to specify properties that affect the
60240 ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
60378 ** that is used by sqlite3_filename_database() and kin also depend on the
60838 ** and possibly used for a transaction later on. Also, write-access
61021 ** data is left as it was when the page object was last used.
61283 ** used if we know that the page being released is not the last page.
61285 ** to routines can be used to release any page other than BtShared.pPage1.
61323 ** as well. This function is only used when the journal file is being
61324 ** opened to write a rollback log for a transaction. It is not used
61460 ** busy-handler callback can be used when upgrading to the EXCLUSIVE
61784 ** This optimization cannot be used with a temp-file, as the page may
61955 ** * the journal is synced (unless the atomic-write optimization is used),
62027 ** should be used. No rollback journal is created if batch-atomic-write
62109 ** If the atomic-update optimization is being used, this sync will not
62113 ** atomic-update optimization is used it is almost certain that the
62192 ** be used as a hot-journal and the current transaction rolled back.
62195 ** truncating or partially zeroing it, so that it cannot be used
62222 ** header with the nRec field set to 0. If such a journal is used as
62257 ** 2) It finalizes the journal file, so that it is not used for hot
62333 ** used by the pager and its associated cache.
62352 ** This routine is used for testing and analysis only.
62559 ** if the VFS used by this pager includes ZipVFS, the entire transaction
62580 ** used to report the filename to the user, for compatibility with legacy
62683 ** A transaction must be active when this routine is called. It used to be
63006 ** Get/set the size-limit used for persistent journal files.
63050 sqlite3 *db, /* Db handle used to check for interrupts */
63061 ** used for this since it starts transactions on every database file,
63154 ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
63255 ** Set the database handle used by the wal layer to determine if
63374 ** This file contains the implementation of a write-ahead log (WAL) used in
63388 ** A single WAL file can be used multiple times. In other words, the
63392 ** used to determine which frames within the WAL are valid and which
63435 ** big-endian format regardless of which byte order is used to compute
63438 ** algorithm used for the checksum is as follows:
63648 ** interoperate. The standard implemention used on both unix and windows
63699 ** information used by checkpoint.
63716 ** The aLock[] field is a set of bytes used for locking. These bytes should
63723 ** a special case; its value is never used and it exists as a place-holder
63868 sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */
63924 ** This structure is used to implement an iterator that loops through
63936 ** This functionality is used by the checkpoint code (see walCheckpoint()).
64266 ** Names of locks. This routine is used to provide debugging output and is not
64342 ** An instance of the WalHashLoc object is used to describe the location
65129 ** Construct a WalInterator object that can be used to loop over all
65147 ht_slot *aTmp; /* Temp space used by merge-sort */
65168 /* Allocate temporary space used by the merge-sort routine. This block
65274 ** Set the database handle used to determine if blocking locks are required.
65326 ** Return the page-size in bytes used by the database.
65345 ** The value of parameter salt1 is used as the aSalt[1] value in the
65700 ** Memory barriers are used to prevent the compiler or the hardware from
65910 ** shared memory to be used in its place.
66136 ** xShmMap() implementation used by the default unix and win32 VFS
66369 ** This routine used to be called sqlite3OpenSnapshot() and with good reason:
67560 ** This file contains code used to implement mutexes on Btree objects.
67738 ** byte are used. The integer consists of all bytes that have bit 8 set and
67741 ** As a special case, all 8 bytes of the 9th byte are used as data. This
67752 ** Variable length integers are used for rowids and to hold the number of
67927 BtLock lock; /* Object used to lock page 1 */
68042 ** An instance of the following structure is used to hold information
68148 ** modified since the cursor was last used. The cursor position is saved
68167 ** The database page the PENDING_BYTE occupies. This page is never used.
68183 ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
68202 ** new location. The pointer map is used to locate the parent page quickly.
68205 ** used in this case.
68208 ** is not used in this case.
68236 ** The ISAUTOVACUUM macro is used within balance_nonroot() to determine
68237 ** if the database supports auto-vacuum or not. Because it is used
68254 ** the database. As the integrity-check proceeds, for each page used in
68256 ** detect pages that are used twice and orphaned pages (both of which
68272 u32 *heap; /* Min-heap used for analyzing cell coverage */
68286 ** two-byte aligned address. get2bytea() is only used for accessing the
68382 ** complex, but seldom used logic, out of sqlite3BtreeLock() and
68402 ** the other BtShared locks that we used to hold in ascending
68441 ** This routine is used only from within assert() statements.
68503 ** This routine is used inside assert() statements only.
68577 ** These entry points are used by incremental I/O only. Enter() is required
68633 ** This routine is used to extract the "offset to cell content area" value
68695 ** manipulate entries in the BtShared.pLock linked list used to store
68776 **** This function is only used as part of an assert() statement. ***
68869 **** This function may be used as part of assert() statements only. ****
68962 ** Add a lock on the table with root-page iTable to the shared-btree used
69106 ***** This routine is used inside of assert() only ****
69119 ** a connection that has already closed. This routine is used inside assert()
69360 ** routine is called just before cursor pExcept is used to modify the
69520 ** cursor returned must not be used with any other Btree interface.
69623 /* The super-journal page number must never be used as a pointer map page */
69639 ** If that byte is set, it means this page is also being used
69945 ** the space used by the cell pointer.
70068 /* This variation on cellSizePtr() is used inside of assert() statements
70283 ** for the portion used by the new allocation. */
70342 ** integer, so a value of 0 is used in its place. */
70812 ** Convert a DbPage obtained from the pager into a MemPage used by
71202 ** The following asserts make sure that structures used by the btree are
71597 ** of the database file used for locking (beginning at PENDING_BYTE,
71664 ** sometimes used by extensions.
73047 ** Statement subtransactions are used around individual SQL statements
73127 ** be used for reading. If the BTREE_WRCSR bit is set, then the cursor
73128 ** can be used for reading or for writing if other conditions for writing
73146 ** this cursor will only be used to seek to and delete entries of an index
73147 ** as part of a larger DELETE statement. The FORDELETE hint is not used by
73353 #ifndef NDEBUG /* The next routine used only within assert() statements */
73357 ** This is a verification routine is used only within assert() statements.
73459 ** the pointer-map was used to obtain the value for *pPgnoNext), then
73552 ** This function is used to read or overwrite payload information
73793 ** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read()
73831 ** pages. When that is so, this routine can be used to access the
73833 ** onto overflow pages, then accessPayload() must be used to reassemble
73876 ** These routines is used to get quick access to key and data
73877 ** in the common case where no overflow pages are used.
74536 ** varint. This information is used to attempt to avoid parsing
74558 ** and accessPayload() used to retrieve the record into the
74869 ** locate a page close to the page number "nearby". This can be used in an
75150 ** becomes a new pointer-map page, the second is used by the caller.
75190 ** This function is used to add page iPage to the database file free-list.
75428 ** Create the byte sequence used to represent a cell on page pPage
75807 ** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
75851 ** are used and they point to the leaf pages only, and the ixNx value are:
76256 ** The pSpace buffer is used to store a temporary copy of the divider
76401 ** This function is used to copy the contents of the b-tree node stored
76413 ** The performance of this function is not critical. It is only used by
76463 ** page are used in the balancing, though both siblings might come from one
76490 ** used to store the parent's overflow cells. Because this function inserts
76786 ** szNew[i]: Spaced used on the i-th sibling page.
76954 ** An O(N*N) sort algorithm is used, but since N is never more than NB+2
77111 ** This can only happen for b-trees used to evaluate "IN (SELECT ...)"
77464 ** has completed, it is safe to release the pSpace buffer used by
77473 /* If pFree is not NULL, it points to the pSpace buffer used
77600 ** is described by the pX object. The pCur cursor is used only to
77604 ** For a table btree (used for rowid tables), only the pX.nKey value of
77605 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
77609 ** For an index btree (used for indexes and WITHOUT ROWID tables), the
77625 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
77663 ** than one table or index with the same root page as used by the cursor.
77848 ** This optimization cannot be used on an autovacuum database if the
77880 ** back to the root page as balance() used to invalidate the contents
77928 ** This function is used as part of copying the current row from cursor
77930 ** parameter iKey is used as the rowid value when the record is copied
78053 ** The BTREE_AUXDELETE bit is a hint that is not used by this implementation,
78054 ** but which might be used by alternative storage engines.
78131 ** from the internal node. The 'previous' entry is used for this instead
78323 /* pgnoRoot is the page that will be used for the root-page of
78535 ** page number that used to be the last root page in the file before
78782 ** Return the pager associated with a BTree. This routine is used for
78978 ** This heap is used for cell overlap and coverage testing. Each u32
79052 u32 *heap = 0; /* Min-heap used for checking cell coverage */
79245 ** overlap, that means bytes are used multiple times. If there is a gap,
79418 checkAppendMsg(&sCheck, "Page %d is never used", i);
79426 checkAppendMsg(&sCheck, "Page %d is never used", i);
79524 ** a single shared-btree. The memory is used by client code for its own
79697 ** only used from within assert() statements
80509 ** to 0. This is used by the implementations of sqlite3_backup_step()
80963 ** used for converting values to text for returning to the user (i.e. via
80964 ** sqlite3_value_text()), or for ensuring that values to be used as btree
81349 ** used (for example) to implement the SQL "cast()" operator.
81570 ** This is used for testing and debugging only - to help ensure that shallow
81605 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
81809 pMem->z[amt] = 0; /* Overrun area used when reading malformed records */
82328 ** This function is used to allocate and populate UnpackedRecord
82546 ** This file contains code used for creating, destroying, and populating
82635 ** that identifier is really used as a string literal.
82704 ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used
83013 ** as having been used.
83064 ** label can be used as the P2 value of an operation. Later, when
83152 ** The following type and function are used to iterate through all opcodes
83154 ** invoke directly or indirectly. It should be used as follows:
83237 ** match, or false otherwise. This function is intended to be used as
83330 ** (2) Compute the maximum number of arguments used by any SQL function
83526 ** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing
83539 ** an OP_ResultRow opcode. Fail an assert() if it does. This is used
83831 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
84397 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
84478 ** Print a single opcode. This routine is used for debugging only.
84759 ** This feature is used to implement "EXPLAIN".
84763 ** are shown in a different format. p->explain==2 is used to implement
84803 /* The first 8 memory cells are used for the result set. So we will
84866 ** Print the SQL that was used to generate a VDBE program.
85041 ** use aMem[0] which is not otherwise used by the VDBE program. Allocate
85046 if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */
85052 n = ROUND8P(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
85182 ** is used, for example, when a trigger sub-program is halted to restore
85305 ** SQLITE_OK so p is not used.
85718 /* Lock all btrees used by the statement */
86265 ** this routine is now only used by the STAT3 logic and STAT3 support has
86563 ** This routine is used to allocate sufficient space for an UnpackedRecord
86564 ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
86644 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
86674 ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
86730 /* No memory allocation is ever used on mem1. Prove this using
87258 /* No memory allocation is ever used on mem1. Prove this using
87287 ** To avoid concerns about buffer overreads, this routine is only used
87774 ** This function is used to free UnpackedRecord structures allocated by
88231 ** The following routines are used by user-defined functions to specify
88239 ** on value P is not going to be used and need to be destroyed.
88560 /* We used to require that sqlite3_reset() be called before retrying
89116 ** The following routines are used to access elements of the current row
89326 ** Routines used to attach values to wildcards in a compiled SQL statement.
89669 ** the first argument to the sqlite3_prepare() that was used to create
90088 ** This file contains code used to insert the values of host parameters
90133 ** can be used to prevent unreasonably large trace strings when dealing
90325 ** This facility is used for testing purposes only. It does not function
90345 ** or MEM_Str that has been used by a VDBE opcode. The test procedures
90371 ** is executed. This is used to test whether or not the foreign key
90412 ** feature is used for test suite validation only and does not appear an
90445 ** should be no-ops except for special builds used to measure test coverage.
90516 /* Find the memory cell that will be used to store the blob of memory
90521 ** * Sometimes cursor numbers are used for a couple of different
90548 /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure
90549 ** the pMem used to hold space for the cursor has enough storage available
90550 ** in pMem->zMalloc. But for the special case of the aMem[] entries used
91217 ** that comment is used to determine the particular value of the opcode.
91219 ** Other keywords in the comment that follows each case are used to
91226 ** comment lines are used in the generation of the opcode.html documentation
91243 ** The P1 parameter is not actually used by this opcode. However, it
91266 /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
91324 ** this opcode is used in combination with OP_BeginSubrtn, and set to 0
91329 ** P2 is not used by the byte-code engine. However, if P2 is positive
91748 ** The P4 value is used by sqlite3_bind_parameter_name().
91821 ** be merged. The 0x0001 bit is used by the query planner and does not
91900 ** exits. This opcode is used to raise foreign key constraint errors prior
91972 /* The registers in the result will not be used again when the
92189 ** be returned. This is used by the built-in min(), max() and nullif()
92196 ** The interface used by the implementation of the aforementioned functions
92337 ** This opcode is used when extracting information from a column that
92399 ** affinity is used. Note that the affinity conversions are stored
92405 ** used to determine the results of the comparison. If both values
92407 ** P4 is used to do the comparison. If P4 is not specified then
92408 ** memcmp() is used to compare text string. If both values are
92409 ** numeric, then a numeric comparison is used. If the two values
92443 ** affinity is used. Note that the affinity conversions are stored
92449 ** used to determine the results of the comparison. If both values
92451 ** P4 is used to do the comparison. If P4 is not specified then
92452 ** memcmp() is used to compare text string. If both values are
92453 ** numeric, then a numeric comparison is used. If the two values
92650 ** Set the permutation used by the OP_Compare operator in the next
92681 ** only. The KeyInfo elements are used sequentially.
93119 ** This opcode does not use P2 itself, but the P2 value is used by the
93164 ** to only be used by the length() function or the equivalent. The content
93166 ** OPFLAG_TYPEOFARG bit is set then the result will only be used by the
93334 ** (2) the entire header was used but not all data was used
93466 ** forces the register type to the Table column type. This is used
93568 ** string indicates the column affinity that should be used for the N-th
93617 ** string indicates the column affinity that should be used for the N-th
93634 ** only used inside an assert() and does not affect the end result.
93717 ** be used for that term in the generated record:
93855 ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
93964 nEntry = 0; /* Not needed. Only used to silence a warning. */
94235 ** file used for temporary tables. Indices of 2 or more are used for
94251 ** This operation is used to detect when that the cookie has changed
94365 ** the main database file and P1==1 is the database file used to store
94397 ** database file used to store temporary tables.
94443 ** P3==0 means the main database, P3==1 means the database used for
94444 ** temporary tables, and P3>1 means used the corresponding attached
94451 ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
94474 ** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
94481 ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
94505 ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
94508 ** <li> <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek
94511 ** ignore. The hint is not used by the official SQLite b*tree storage
94512 ** engine, but is used by COMDB2.
94613 ** SQLite used to check if the root-page flags were sane at this point
94635 ** Duplicate ephemeral cursors are used for self-joins of materialized views.
94688 ** can be used as zero-length data for OP_Insert. This is an optimization
94696 ** by this opcode will be used for automatically created transient
94713 /* Make register reg[P3] into a value that can be used as the data
94715 assert( pOp->p2==0 ); /* Only used when number of columns is zero */
94826 ** A pseudo-table created by this opcode is used to hold a single
94870 ** table or index for cursor P1 are used. P4 is a 64-bit integer
94872 ** first 63 columns of the table or index that are actually used
94874 ** the 64th is used.
94891 ** that are used as an unpacked index key.
94902 ** IdxGT opcode will be used on subsequent loop iterations. The
94918 ** that are used as an unpacked index key.
94936 ** that are used as an unpacked index key.
94954 ** that are used as an unpacked index key.
94969 ** IdxGE opcode will be used on subsequent loop iterations. The
95186 ** the P1, P2 and P5 operands of this opcode are also used, and are called
95300 res = 0; /* Not needed. Only used to silence a warning. */
95463 ** This opcode is used in IN clause processing for a multi-column key.
95659 ** changing the datatype of pIn3, however, as it is used by other
95726 ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
95727 ** The record number is not previously used as a key in the database
95735 ** generated record number. This P3 mechanism is used to help implement the
95835 ** it finds one that is not previously used. */
95877 ** seeks on the cursor or if the most recent seek used a key equal to P3.
95902 const char *zDb; /* database name - used by the update hook */
95903 Table *pTab; /* Table structure - used by update and pre-update hooks */
95983 ** of table - intkey or index. This opcode is used as part of copying
95986 ** P1. If they are opened on index tables, P3 is not used.
96147 ** This is used by trigger programs.
96288 ** P1 can be either an ordinary table or a virtual table. There used to
96374 ** It is assumed that the cursor is used only for appending and so
96460 ** This opcode is an alias for OP_Sort and OP_Rewind that is used
96466 ** it increments an undocumented global variable used for testing.
96537 ** OP_Rewind opcode used to position the cursor. Next is not allowed
96562 ** OP_Last opcode used to position the cursor. Prev is not allowed
96660 ** seeks on the cursor or if the most recent seek used a key equivalent
96778 ** the cursor is used to read a record. That way, if no reads
96785 ** from P1. This information is stored in P3 and used to redirect
96823 rowid = 0; /* Not needed. Only used to silence a warning. */
96998 ** that is used to store tables create using CREATE TEMPORARY TABLE.
97059 ** that is used to store tables create using CREATE TEMPORARY TABLE.
97093 ** This opcode only works for cursors used for sorting and
97239 ** the analysis to be used when preparing all subsequent queries.
97310 ** This opcode is used to implement the integrity_check pragma.
97456 ** cell in an array of values used as arguments to the sub-program. P2
97459 ** of a memory cell in this (the parent) VM that is used to allocate the
97503 /* Register pRt is used to store the memory required to save the state
97508 /* SubProgram.nMem is set to the number of memory cells used by the
97510 ** cell is required for each cursor used by the program. Set local
97603 ** address space. This is used by trigger programs to access the new.*
97721 ** This opcode performs a commonly used computation associated with
97957 ** argument is not used by this opcode. It is only there to disambiguate
97969 ** argument is not used by this opcode. It is only there to disambiguate
98249 ** Obtain a lock on a particular table. This instruction is only used when
98259 ** used to generate an error message if the lock cannot be obtained.
98395 ** can be used as the first argument to sqlite3_vtab_in_first() and
98397 ** cursor. Register P3 is used to hold the values returned by
98489 ** If the VColumn opcode is being used to fetch the value of
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
98778 ** its name. This opcode is used in places where the function must be
98781 ** When those function are used in a non-deterministic way, they will check
98889 ** more CPU cycles to be used, but it should still yield the correct
99080 ** before their are used, under the (valid) assumption that the registers
99081 ** will not be reallocated for some other purpose before they are used and
99114 ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
99161 ** used. */
99270 ** This file contains code used to implement incremental BLOB I/O.
99295 ** This function is used by both blob_open() and blob_reopen(). It seeks
99788 ** This file contains code for the VdbeSorter object, used in concert with
99848 ** unsorted in main memory. Assuming the amount of memory used never exceeds
99854 ** If the amount of space used to store records in main memory exceeds the
99897 ** Parameter T is set to half the value of the memory threshold used
99901 ** Rewind() is called, then a hierarchy of incremental-merges is used.
99934 ** Private objects used by the sorter
99969 ** The MergeEngine object is used to combine two or more smaller PMAs into
100054 ** right before it exits, the thread itself sets bDone to 1. This is used for
100108 u8 iPrev; /* Previous thread used to flush PMA */
100118 ** An instance of the following object is used to read records out of a
100143 ** an object of the following type, it may be used to iterate/merge through
100183 ** An instance of this object is used for writing a PMA.
100228 ** object p. Should be used as if:
100550 ** used by the comparison. Return the result of the comparison.
100692 ** is used instead. This is used when sorting records for a CREATE INDEX
101327 PmaWriter writer; /* Object used to write to the file */
101331 ** This is used by an assert() statement at the end of this function. */
101480 SortSubtask *pTask = 0; /* Thread context used to create new PMA */
101652 ** of the data stored in aFile[1] is the same as that used by regular PMAs,
101858 ** SQLITE_MAX_WORKER_THREADS==0). The other values are only used
102190 ** can be used to incrementally merge all PMAs on disk.
102271 ** (for multi-threaded sorters) so that it can be used to iterate through
102506 ** turn is used to verify uniqueness when constructing a UNIQUE INDEX.
102986 ** The in-memory rollback journal is used to journal transactions for
102987 ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
102989 ** Update: The in-memory journal is also used to temporarily cache
103183 ** the in-memory journal is being used by a connection using the
103427 ** This file contains routines used for walking the parser tree for
103656 ** when this routine is used for Walker.xExprCallback then
103688 ** This file contains routines used for walking the parser tree and
103899 ** can be used. The zTable variable is the name of the table (the "Y"). This
103902 ** can be used.
103912 NameContext *pNC, /* The name context used to resolve the name */
104240 ** on sqlite3_log() whenever the capability is used.
104312 ** to be compatible with MySQL 3.x, which used double-quotes for strings.
104394 ** set if the 63rd or any subsequent column is used.
104396 ** The colUsed mask is an optimization used to help determine if an
104552 ** column in the FROM clause. This is used by the LIMIT and ORDER BY
104735 ** sqlite_version() that might change over time cannot be used
104736 ** in an index or generated column. Curiously, they can be used
104753 ** used to activate internal functions for testing purposes */
104772 "%#T() may not be used as a window function", pExpr
104812 "FILTER may not be used with non-aggregate %#T()",
105026 ** same integer value that would be used in the SQL statement to indicate
105734 ** subqueries in expressions, and subqueries used as FROM clause
105825 ** This file contains routines used for analyzing expressions and
106018 /* The Expr.x union is never used at the same time as Expr.pRight */
106071 ** type affinity that should be used for the comparison operator.
106115 ** if the index with affinity idx_affinity may be used to implement
106130 ** Return the P5 value that should be used for a binary comparison
106131 ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
106144 ** Return a pointer to the collation sequence that should be used by
106148 ** used. Otherwise the collation sequence for the right hand expression
106149 ** is used, or the default (BINARY) if neither expression has a collating
106317 ** pRight: not used. But recursively deleted.
106535 ** and heightOfSelect(), are used to determine the maximum height
106809 ** This is used as part of processing IN(...) expressions with a list
107046 /* The Expr.x union is never used at the same time as Expr.pRight */
107363 ** gatherSelectWindowsCallback() are used to scan all the expressions
107568 ** to be used by the code generator. */
107594 ** may not be used with an ExprList obtained from sqlite3ExprListDup().
107884 ** This callback is used by multiple expression walkers.
107967 ** These routines are Walker callbacks used to check expressions to
107972 ** These callback routines are used to implement the following:
107982 ** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT
108154 ** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy().
108186 ** This routine is used to determine if a term of the HAVING clause can
108299 ** This routine is used as an optimization, to skip OP_IsNull opcodes
108339 ** This routine is used to determine if the OP_Affinity operation
108470 ** This function is used by the implementation of the IN (...) operator.
108475 ** be used either to test for membership in the RHS set or to iterate through
108491 ** An existing b-tree might be used if the RHS expression pX is a simple
108506 ** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast
108508 ** be used to loop over all values of the RHS of the IN operator.
108510 ** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate
108516 ** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used
108518 ** be used unless <columns> is a single INTEGER PRIMARY KEY column or an
108528 ** When the b-tree is being used for membership tests, the calling function
108587 /* Check to see if an existing table or index can be used to
108624 /* Check that the affinity that will be used to perform each
108653 Bitmask colUsed; /* Columns of the index used */
108670 colUsed = 0; /* Columns of index used so far */
108688 if( mCol & colUsed ) break; /* Each column used only once */
108774 ** the affinities to be used for each column of the comparison.
108820 ** Expression pExpr is a vector that has been used in a context where
108858 ** column is used to build the index keys. If both 'x' and the
108859 ** SELECT... statement are columns, then numeric affinity is used
108862 ** is used.
109050 ** Generate code for scalar subqueries used as a subquery expression
109298 ** even if it is constant, as OP_Affinity may be used on the register
109691 ** the first register used to store the result.
109836 ** the type affinity of the argument. This is used for testing of
110269 u8 enc = ENC(db); /* The text encoding used by this database */
110663 "RAISE() may only be used within a trigger-program");
110847 ** filled using OP_SCopy. OP_Copy must be used instead.
111388 ** this routine is used, it does not hurt to get an extra 2 - that
111765 ** This routine is used to check if a LEFT JOIN can be converted into
111793 ** An instance of the following structure is used by the tree walker
111833 Index *pIdx /* The index that might be used for coverage */
111847 /* Structure used to pass information throught the Walker in order to
111851 sqlite3 *db; /* Database connection used for sqlite3DbRealloc() */
111936 ** As currently used, pExpr is always an aggregate function call. That
112059 ** This is the xExprCallback for a tree walker. It is used to
112338 ** This file contains C code routines that used to generate VDBE code
112596 ** of any resources used by the v-table implementation (including other
113016 ** routine is used to keep the mapping current.
113018 ** After the parse finishes, renameTokenFind() routine can be used
113063 ** following a valid object, it may not be used in comparison operations.
113091 ** The pPtr argument is returned so that this routine can be used
113133 ** Walker callback used by sqlite3RenameExprUnmap().
113195 ** Walker callback used by sqlite3RenameExprUnmap().
113451 ** is initialized by this function before it is used.
113782 ** This function is used internally by the ALTER TABLE RENAME COLUMN command.
113952 ** Walker expression callback used by "RENAME TABLE".
113966 ** Walker select callback used by "RENAME TABLE".
113994 ** This C function implements an SQL user function that is used by SQL code
114591 ** Register built-in functions used to help implement ALTER TABLE
114632 ** The sqlite_stat2 table is not created or used unless the SQLite version
114636 ** created and used by SQLite versions 3.7.9 through 3.29.0 when
114675 ** The sqlite_stat2 is only created and is only used if SQLite is compiled
114899 u32 iPrn; /* Pseudo-random number used for sampling */
114909 /* Reclaim memory used by a StatSample
115088 ** (given by the 3rd parameter) is never used and can be any positive
115299 ** The stat_get() SQL function will be used afterwards to
115305 ** The R parameter is only used for STAT4
115402 ** used to query statistical information that has been gathered into
115936 ** be loaded into internal hash tables where is can be used.
116455 ** contents of sqlite_stat1 are used to populate the Index.aiRowEst[]
116456 ** arrays. The contents of sqlite_stat4 are used to populate the
116558 ** This file contains code used to implement the ATTACH and DETACH commands.
116595 ** Return true if zName points to a name that may be used to refer to
116668 ** * Specified database name already being used.
117019 ** Expression callback used by sqlite3FixAAAA() routines.
117036 ** Select callback used by sqlite3FixAAAA() routines.
117088 int iDb, /* This is the database that must be used */
117115 ** These routines are used to make sure that an index, trigger, or
117198 ** This file contains code used to implement the sqlite3_set_authorizer()
117486 ** The TableLock structure is only used by the sqlite3TableLock() and
117576 ** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero()
117662 ** set for each database that is used. Generate code to start a
117663 ** transaction on each used database and to verify the schema cookie
117664 ** on each used database.
117736 /* A minimum of one cursor is required if autoincrement is used
118015 ** Reclaim the memory used by an index
118267 ** db parameter can be used with db->pnBytesFreed to measure the memory
118268 ** used by the Table object.
118280 ** that no lookaside memory is used in this case either. */
118325 /* Verify that no lookaside memory was used by schema tables */
118505 ** This routine is used to check if the UTF-8 string zName is a legal
118563 ** if column iCol is not used in index pIdx.
118609 ** follow the range of registers used to construct storage. This
118654 ** is used by CREATE TABLE IF NOT EXISTS and similar if the table already
118752 ** and types will be used, so there is no need to test for namespace
118886 ** Name of the special TEMP trigger used to implement RETURNING. The
119227 /* A copy of pExpr is used instead of the original, as pExpr contains
119491 ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
119500 ** The schema cookie is used to determine when the schema for the
119526 ** identifier. The number returned includes any quotes used
119703 ** This is used to determine if the column number x appears in any of the
119801 ** columns are part of KeyInfo.nAllField and are not used for
120194 ** actually be used if PRAGMA writable_schema=ON is set. */
120278 ** suitable state to query for the column names and types to be used
120403 /* If this is the magic sqlite_sequence table used by autoincrement,
120675 ** used by SQLite when the btree layer moves a table root page. The
121005 /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
121197 ** used to initialize a newly created index or to recompute the
121208 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
121209 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
121639 ** TODO: Issue a warning if the table primary key is used as part of the
121970 ** to be used when we have not run the ANALYZE command.
122173 assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */
122195 ** The SrcList object is used to represent the FROM clause of a
122421 Select *pSubquery, /* A subquery used in place of a table name */
123049 Select *pQuery, /* Query used to initialize the table */
123168 ** This file contains functions used to access the internal hash tables
123224 ** This routine is called on a collation sequence before it is used to
123353 ** The return value is either the collation sequence to be used in database
123544 ** case is used to see if zName is a valid function name for some number
123994 int memCnt = 0; /* Memory cell used for change counting */
124192 /* For a WITHOUT ROWID table, create an ephemeral table used to
124206 ** to indicate the strategy used to implement this delete:
124468 int iCol; /* Iterator used while populating OLD.* */
124481 ** used by any BEFORE and AFTER triggers that exist. */
124636 ** The pPrior and regPrior parameters are used to implement a cache to
125567 ** just a variation of LIKE) gets called. This is used for testing
125687 ** that identifies the particular version of the source code used to build
125719 ** was used to build SQLite.
125743 ** used to build SQLite.
125966 ** must be exact. Collating sequences are not used.
126147 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
126164 ** is only available if the SQLITE_SOUNDEX compile-time option is used
126268 ** Routines used to compute the sum, average, and total.
126424 /* This step function is used for both the min() and max() aggregates,
126482 ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
126953 ** For peak efficiency, put the most frequently used function last.
127135 ** This file contains code used by the compiler to add foreign key
127212 ** is that the counter used is stored as part of each individual statement
127235 ** coding an INSERT operation. The functions used by the UPDATE/DELETE
127684 NameContext sNameContext; /* Context used to resolve WHERE clause */
127685 WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */
127703 ** The collation sequence used for the comparison should be that of
127731 ** The first form is used for rowid tables. The second form is used
127733 ** (a,b,...). Either the parent or primary key could be used to
127975 ** used to code a trigger that is really a "SET NULL" action belonging
128383 ** parent table are used for the comparison. */
128823 ** have been opened at any point in the VDBE program. This is used to see if
128992 ** AutoincInfo structure is used.
129053 ** register used by the autoincrement tracker.
129259 ** The 4th template is used if the insert statement takes its
129319 int regRowCount = 0; /* Memory cell used for the row counter */
129539 ** A temp table must be used if the table being updated is also one
129761 ** triggers, the slots used for stored columns will be OP_Copy-ed
130120 ** The IndexIterator object is used to walk through all of the indexes
130265 ** is used. Or if pParse->onError==OE_Default then the onError value
130266 ** for the constraint is used.
130291 int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
130302 int regTrigCnt; /* Register used to count replace trigger invocations */
130492 ** The order of constraints used to have OE_Update as (2) and OE_Abort
130583 ** used to link together these tests which are separated from each other
131160 int *aRegIdx, /* Register used by each index. 0 for unused indices */
131301 ** transfer optimization is used. This is used for testing
131370 ** This routine returns TRUE if the optimization is guaranteed to be used.
131401 int regAutoinc; /* Memory register used by AUTOINC */
131919 ** This file contains code used to dynamically load extensions into
132294 ** This is the function signature used for all extension entry points. It
132307 ** This header file is also used by the loadext.c source file
133160 ** default entry point name (sqlite3_extension_init) is used. Use
133543 ** This file contains code used to implement the PRAGMA command.
134279 ** to support legacy SQL code. The safety level used to be boolean
134280 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
134311 /* The sqlite3GetBoolean() function is used by other modules but the
134864 ** The absolute value of N is used. This is undocumented and might
135150 ** used to limit the aggregate size of all memory mapped regions of the
135152 ** is not used at all. If N is negative, then the default memory map
135215 ** the value sets a specific directory to be used for temporary files.
135259 ** the value sets a specific directory to be used for database files that
135301 ** the value sets a specific file to be used for database access locks.
135863 ** used will be case sensitive or not depending on the RHS.
136038 ** will also prepopulate the cursor column cache that is used
136316 ** encoding that will be used for the main database file if a new file
136318 ** default text encoding for the existing database is used.
136325 ** In the second form this pragma sets the text encoding to be used in
136390 ** The pragma's schema_version and user_version are used to set or get
136397 ** creating or dropping a table or index). The schema version is used by
136399 ** of the schema used when compiling the SQL query matches the schema of
136405 ** The user-version is not used internally by SQLite. It may be used by
136455 ** Return the names of all compile-time options used in this build,
136569 ** (2) The query planner used sqlite_stat1-style statistics for one or
136605 /* If table pTab has not been used in a way that would benefit from
137336 ** database file is given by iDb. iDb==0 is used for the main
137337 ** database. iDb==1 should never be used. iDb>=2 is used for
137573 ** used to store temporary tables, and any additional database files
137690 ** function should never be used.
137747 ** cost for this mechansim (an extra malloc), so it should not be used
138228 ** An instance of the following object is used to record information about
138236 int tabTnct; /* Ephemeral table used for DISTINCT processing */
138241 ** An instance of the following object is used to record information about
138244 ** The aDefer[] array is used by the sorter-references optimization. For
138245 ** example, assuming there is no index that can be used for the ORDER BY,
138254 ** When the sorter-reference optimization is used, there is one entry in the
138341 Expr *pLimit /* LIMIT value. NULL means not used */
138534 ** Mark a subquery result column as having been used.
138596 ** The EP_OuterON property is used on terms of an expression to tell
138638 /* Undo the work of sqlite3SetJoinExpr(). This is used when a LEFT JOIN
138980 pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */
139052 ** iMem form a distinct entry. This is used by both "SELECT DISTINCT ..." and
139054 ** are available. Which is used depends on the value of parameter eTnctType,
139078 ** in an array of registers used to store the previous result row so that
139087 ** Parameter pEList is the list of expressions used to generated the
139088 ** contents of each row. It is used by this routine to determine (a)
139090 ** collation sequences that should be used for the comparisons if
139096 int iTab, /* A sorting index used to test for distinctness */
139209 ** optimization should be used for. The sorter-reference optimization
139210 ** is used for SELECT queries like:
139214 ** If the optimization is used for expression "bigblob", then instead of
139296 ** zero or more, then data is pulled from srcTab and p->pEList is used only
139699 /* Discard the results. This is used for SELECT statements inside
139769 ** This routine is used only inside of assert() statements.
139813 ** Name of the connection operator, used for error messages.
140096 ** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
140159 ** used. When columnType() is called on the expression
140295 ** column has an AS clause assigning it a name, that will be the name used.
140406 ** column has an AS clause assigning it a name, that will be the name used.
140533 Select *pSelect, /* SELECT used to determine types and collations */
140557 /* pCol->szEst = ... // Column size est for SELECT tables never used */
140636 ** are the integer memory register numbers for counters used to compute
140825 int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */
141343 /* Compute collating sequences used by
141432 ** generated to suppress duplicates. pKeyInfo is used for comparing
141536 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
141593 ** <operator> is used:
141728 /* Compute the comparison permutation and keyinfo that is used with
141729 ** the permutation used to determine if the next
142243 ** Expression walker callback used by renumberCursors() to update
142265 ** Argument aCsrMap is an array that may be used for temporary working
142268 ** * the array is larger than the largest cursor number used within the
142389 ** use ORDER BY. (Ticket #2942) This used to not matter
142767 ** iParent. The iParent cursor will never be used. Subsequent code
142796 ** outer query (the middle slot) is used by the subquery. The next
143140 ** columns with BLOB affinity is only allowed if the constant is used with
143198 ** BY clause of all window function used by the sub-query. It is safe
143233 ** (1) (** This restriction was removed on 2017-09-29. We used to
143274 ** all window-functions used by the sub-query. It is safe to
143393 ** *ppMinMax to be an ORDER BY clause to be used for the optimization
143719 ** (1) It is part of a trigger that used to have zDatabase but had
143874 ** This function is used as the xSelectCallback2() callback by
144639 Index *pIdx /* Index used to optimize scan, or NULL */
144655 ** sqlite3WalkExpr() callback used by havingToWhere().
145037 ** of the LEFT JOIN used in the WHERE clause.
145394 ** used for both the ORDER BY and DISTINCT processing. As originally
145426 ** not needed. The sSort.addrSortIndex variable is used to facilitate
145448 /* Delete or NULL-out result columns that will never be used */
145572 int sortPTab = 0; /* Pseudotable used to decode sorting results */
145749 /* Initialize memory locations used by GROUP BY aggregate processing
145840 /* If the index or temporary table used by the GROUP BY sort
145993 ** In practice the KeyInfo structure will not be used. It is only
146178 ** if they are not used.
146185 ** This structure is used to pass data from sqlite3_get_table() through
146194 u32 nData; /* Slots used in azResult[]. (nRow+1)*nColumn */
147405 /* Figure out the ON CONFLICT policy that will be used for this step
147475 ** This function is used to add VdbeComment() annotations to a VDBE
147476 ** program. It is not used in production code, only for debugging.
147492 ** Parse context structure pFrom has just been used to create a sub-vdbe
147781 ** old.* or new.* tables actually are used by triggers. This information
147782 ** may be used by the caller, for example, to avoid having to load the entire
147864 Expr *pRowidExpr, /* Expression used to recompute the rowid */
148024 ** rowid value in <other-columns> is used as the integer key, and the
148255 ** The index cursors might not be used, but if they are used they
148372 ** generated expressions is not used, other than to check to see that it
148398 /* The SET expressions are not actually used inside the WHERE loop.
148571 ** things might disturb a cursor being used to scan through the table
148581 ** be used if any column of the index used for the scan is being
148756 ** row data. This array is used to check constants, create the new
148766 ** be used eliminates some redundant opcodes.
148865 /* If REPLACE conflict handling may have been used, or if the PK of the
149007 ** "onepass" strategy. Onepass is only used if the virtual table
149029 Expr *pRowid, /* Expression used to recompute the rowid */
149044 int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */
149288 int iCursor; /* Cursor used by pTab */
149522 ** This file contains code used to implement the VACUUM command.
149586 ** The VACUUM command is used to clean up the database,
149859 ** The increment is used to increase the schema cookie so that other
149948 ** This file contains code used to help implement virtual tables.
149956 ** this struct allocated on the stack. It is used by the implementation of
150042 ** External API function used to create a new virtual-table module.
150057 ** External API function used to create a new virtual-table module.
150125 ** Return a pointer to the VTable object used by connection db to access
150204 ** used when closing database connection db to free all of its VTable
150206 ** be being used by other shared-cache connections).
150739 ** This function is used to set the schema of a virtual table. It is only
151054 ** This routine is used to allow virtual table implementations to
151296 ** This module contains C code that generates VDBE code used to process
151357 int iMatch; /* Cursor used to determine prior matched rows */
151380 int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */
151381 int iTabCur; /* The VDBE cursor used to access the table */
151382 int iIdxCur; /* The VDBE cursor used to access pIdx */
151399 int p1, p2; /* Operands of the opcode used to end the loop */
151404 int iCur; /* The VDBE cursor used by this IN operator */
151450 u16 nDistinctCol; /* Index columns used to sort for DISTINCT */
151451 Index *pIndex; /* Index used, or NULL */
151469 WhereTerm **aLTerm; /* WhereTerms used */
151560 ** fields. The translation is used in order to maximize the number of
151591 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
151611 #define TERM_HEURTRUTH 0x2000 /* Heuristic truthProb used */
151615 # define TERM_HIGHTRUTH 0 /* Only used with STAT4 */
151620 ** An instance of the WhereScan object is used as an iterator for locating
151697 ** For example, if the WHERE clause expression used these VDBE
151703 ** 57->5, 73->4. Or one of 719 other combinations might be used. It
151733 #define SQLITE_BLDF1_INDEXED 0x0001 /* An index is used */
151734 #define SQLITE_BLDF1_UNIQUE 0x0002 /* All keys of a UNIQUE index used */
151738 /* The WhereLoopBuilder.iPlanLimit is used to limit the number of
151883 ** OR-ed combination of these values can be used when searching for
152206 ** sqlite3_stmt_scanstatus() entry corresponding to the scan used to
152387 ** Since only columns e and c can be used with the index, in that order,
152393 ** only used for indexing, to improve performance. The original unaltered
152698 Index *pIdx; /* The index being used for this loop */
152843 Index *pIdx; /* The index used to access the table */
152898 ** This function is called on every node of an expression tree used as an
152910 ** by pCCurHint.iTabCur, and an index is being used (which we will
153013 /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize
153264 Index *pIdx = 0; /* Index used by loop (if any) */
153614 ** The z<10 term of the following cannot be used, only
153623 ** This case is also used when there are no WHERE clause
153741 /* In case OP_SeekScan is used, ensure that the index cursor does not
153991 /* Record the instruction used to terminate the loop. */
154057 int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */
154059 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
154289 ** processed or the index is the same as that used by all previous
154559 /* Create a subroutine used to process all interior loops and code
154709 ** This module contains C code that generates VDBE code used to process
154752 ** WARNING: This routine might reallocate the space used to store
155313 ** potentially be used with an index if an appropriate index exists.
155465 ** sure the same column is used on all terms. The 2-bit case is when
155630 ** a bitmask indicating which tables are used in that expression
155812 extraRight = x-1; /* ON clause terms may not be used with an index
156088 ** no longer used.
156121 ** used by each such virtual term is pExpr (the full vector IN(...)
156154 ** This information is used by the xBestIndex methods of
156194 /* Prevent ON clause terms of a LEFT JOIN from being used to drive
156401 ** a bitmask indicating which tables are used in that expression
156562 ** This module contains C code that generates VDBE code used to process
156565 ** rows. Indices are selected and used to speed the search when doing
156706 ** optimization can be used on multiple
156708 ** If the ONEPASS optimization is used (if this routine returns true)
156709 ** then also write the indices of open cursors used by ONEPASS
156711 ** table and iaCur[1] gets the cursor used by an auxiliary index.
156712 ** Either value may be -1, indicating that cursor is not used.
157305 ** for an example of a WHERE clause constraints that may not be used on
157336 ** could be used with an index to access pSrc, assuming an appropriate
157392 Bitmask idxCols; /* Bitmap of columns used for indexing */
157408 ** and used to match WHERE clause constraints */
157418 ** rows of the target table (pSrc) that can be used. */
157458 ** original table changes and the index and table cannot both be used
158312 ** This function is used to estimate the number of rows that will be visited
158347 ** used, a single range inequality reduces the search space by a factor of 4.
158385 ** ($P:$L) and the larger of the two returned values is used.
158390 ** of iUpper are requested of whereKeyStats() and the smaller used.
158768 ** Deallocate internal memory used by a WhereLoop object. Leave the
158854 ** (3) Every WHERE clause term used by X is also used by Y
158882 if( j<0 ) return 0; /* X not a subset of Y since term X[i] not used by Y */
158902 ** WHERE clause terms than Y and that every WHERE clause term used by X is
158903 ** also used by Y.
159022 ** processing mode is used only for OR clause processing.
159144 ** WHERE clause that reference the loop but which are not used by an
159147 ** For every WHERE clause term that is not used by the index
159152 ** TUNING: For every WHERE clause term that is not used by the index
159154 ** described below are used to try to estimate the truth probability.
159195 /* If there are extra terms in the WHERE clause not used by an index
159246 ** function returns the total number of vector elements that can be used
159263 Index *pIdx, /* The index to be used for a inequality constraint */
159332 ** a fake index used for the INTEGER PRIMARY KEY.
159537 ** always used in pairs. */
159616 /* If the term has previously been used with an assumption of
159766 /* Check to see if a partial index with pPartIndexWhere can be used
159842 ** pIdx is an index that covers all of the low-number columns used by
159873 ** colMask that columns greater than 62 are used, so this is not a
159913 ** WHERE clause includes "x IN (....)" terms used in place of "x=?". Or when
160161 ** because the cursor used to access the index might not be
160175 /* If a non-unique index is used, or if a prefix of the key for
160176 ** unique index is used (making the index functionally non-unique)
160203 ** be used by the virtual table identified by pBuilder->pNew->iTab. This
160223 Bitmask mPrereq, /* Mask of tables that must be used. */
160502 ** This is used by the (built-in) sqlite_dbpage virtual table.
160559 Bitmask mBest; /* Tables used by best possible plan */
161010 ** optimization, and then only if they are actually used
161073 ** check that it is the only column used by this loop. Otherwise,
161347 char *pSpace; /* Temporary memory used by this routine */
161812 sqlite3DebugPrintf("whereShortCut() used to compute solution\n");
161941 WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));
162027 ** The index pIdx is used by a query and contains one or more expressions.
162084 ** Generate the beginning of the loop used for WHERE clause processing.
162130 ** to see if there are indices that can be used to speed up the loop.
162132 ** Terms of the WHERE clause are also used to limit which rows actually
162168 ** be used to compute the appropriate cursor depending on which index is
162169 ** used.
162230 ** return value. A single allocation is used to store the WhereInfo
162396 /* If one or more WhereTerm.truthProb values were used in estimating
162500 ** A one-pass approach can be used if the caller has requested one
162504 ** * the caller has indicated that a one-pass approach can be used
162578 /* If we know that only a prefix of the record will be used,
163148 ** functions may be used) is transformed by function sqlite3WindowRewrite()
163181 ** be used to process more than one window function. For example:
163246 ** can be used as either aggregates or window funtions) allows them to
163289 ** Context object type used by rank(), dense_rank(), percent_rank() and
163329 ** implementation is used in "slow mode" only - when the EXCLUDE clause
163668 ** names are used, rather than string literals, so that FuncDef objects
163817 "FILTER clause may only be used with aggregate window functions"
163870 ** Callback function used by selectWindowRewriteEList(). If necessary,
163881 ** that used by the SELECT statement being processed, only process
164141 /* Assign a cursor number for the ephemeral table used to buffer rows.
164338 ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending
164339 ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting
164511 ** to begin iterating through the sub-query results. It is used to allocate
164512 ** and initialize registers and cursors used by sqlite3WindowCodeStep().
164551 ** table and 3 registers. The registers are used as follows:
164554 ** regApp+1: integer value used to ensure keys are unique
164574 /* Allocate two registers at pWin->regApp. These will be used to
164726 int regGosub; /* Register used with OP_Gosub(addrGosub) */
165216 ** A special type of arithmetic is used such that if csr1.peerVal is not
165577 ** used to implement window frames of the form:
165913 int csrWrite; /* Cursor used to write to eph. table */
165989 ** samve values in record form, and the rowid used to insert said record
166432 /* Add a single new term to an ExprList that is used to store a
166651 ** YYCODETYPE is the data type used to store the integer codes
166653 ** "unsigned char" is used if there are fewer than
166655 ** YYNOCODE is a number of type YYCODETYPE that is not used for
166659 ** values which should be used if the original symbol
166661 ** be used as identifiers, for example.
166662 ** YYACTIONTYPE is the data type used for "action codes" - numbers
166665 ** sqlite3ParserTOKENTYPE is the data type used for minor type for terminal
166674 ** YYMINORTYPE is the data type used for all minor types.
166773 /* Next are the tables used to determine what action to take based on the
166774 ** current state and lookahead token. These tables are used to implement
166803 ** The (A) formula is preferred. The B formula is used instead if
166808 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
167448 ** This feature can be used, for example, to cause some keywords in a language
167651 ** the information used by the action routines in the grammar.
168539 ** A pointer to the function used to allocate memory.
168542 ** A pointer to a parser. This pointer is used in subsequent calls
168560 ** a pointer to the value to be deleted. The code used to do the
168579 ** which appear on the RHS of the rule, but which are *not* used
168724 void (*freeProc)(void*) /* Function used to reclaim memory */
168756 ** (1) has not been used by the parser, and
171704 ** a lookup table is used, all of the classes need to be small integers and
171705 ** all of them need to be used within the switch.
171785 ** which are the only characters for which this feature is used.
172316 ** If X is a character that can be used in an identifier then
173035 ** This code used to be part of the tokenizer.c source file. But by
173057 ** Token types used by the sqlite3_complete() routine. See the header
173129 /* A complex statement machine used to detect the end of a CREATE TRIGGER
173146 ** used to detect the end of a statement is much simpler
173207 case '`': /* Grave-accent quoted symbols used by MySQL */
173347 ** This header file is used by programs that want to link against the
173380 ** This header file is used by programs that want to link against the
173417 ** This header file is used by programs that want to link against the
173560 ** name of a directory, then that directory will be used to store
173569 ** name of a directory, then that directory will be used to store
173896 ** low-level memory allocation routines to be used in place of the memory
174468 ** This collating sequence is intended to be used for "case independent
174470 ** extends only to the 26 characters used in the English language.
175286 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
175371 ** Worker function used by utf-8 APIs that create new functions:
175502 ** fails with an error message stating that the function is used in the
175968 ** This function returns true if main-memory should be used instead of
176140 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
176312 ** This function is used to parse both URIs and non-URI filenames passed by the
176325 ** the VFS that should be used to open the database file. *pzFile is set to
176724 ** the temporary files used to do external sorts (see code in vdbesort.c)
176725 ** is disabled. It can still be used either by defining
176836 ** Throw an error if any non-sense combination is used. If we
177157 ** This function is now an anachronism. It used to be used to recover from a
177489 ** be used for the next call to sqlite3_randomness().
177601 ** issue "defined but not used" warnings. */
177798 ** This test control is used to create imposter tables. "db" is a pointer
177934 ** Transient use only. Tuning parameters should not be used in
178317 ** was used and false if not.
178422 ** set to db. This is used when closing connection db.
178769 ** FTS3 used to optionally store character offsets using a compile-time
179047 ** Defines the interface to tokenizers used by fulltext-search. There
179054 ** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
179063 /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
179070 ** Structures used by the tokenizer interface. When a new tokenizer
179080 ** be used for the fts3 table (customized by the tokenizer clause arguments).
179084 ** that may be used to tokenize a specific input buffer based on
179219 ** used in SQLite. We've modified it slightly to serve as a standalone
179254 ** be opaque because it is used by macros.
179270 ** memcmp() is used to compare keys.
179346 ** and used to create a new segment when the transaction is committed.
179369 ** from that used by SQLite, so the maximum length is 10, not 9.
179394 ** The testcase() macro is only used by the amalgamation. If undefined,
179409 ** is used for assert() conditions that are true only if it can be
179444 ** Internal types used by SQLite.
179453 ** Macro used to suppress compiler warnings for unused parameters.
179465 ** The TESTONLY macro is used to enclose variable declarations or
179511 sqlite3_vtab base; /* Base class used by SQLite core */
179525 /* Precompiled statements used by the implementation. Each of these
179545 ** The following array of hash tables is used to buffer pending index
179573 /* State variables used for validating that the transaction control
179575 ** values do not contribute to FTS functionality; they are used for
179605 sqlite3_vtab_cursor base; /* Base class used by SQLite core */
179656 ** bits, used to describe extra constraints on full-text searches.
179687 ** used when evaluating the expression. */
179720 ** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global
179740 /* The following are used by the fts3_eval.c module. */
179746 /* The following are used by the fts3_snippet.c module. */
180507 ** could be used in a SELECT statement such as the following:
180634 ** This function is used when parsing the "prefix=" FTS4 parameter.
180826 sqlite3_int64 nByte; /* Size of allocation used for *p */
181220 ** extension is currently being used by a version of SQLite too old to
181233 ** extension is currently being used by a version of SQLite too old to
181514 ** This function is used to process a single interior node when searching
181705 ** This function is used to create delta-encoded serialized lists of FTS3
181801 ** Value used to signify the end of an position-list. This must be
181808 ** This function is used to help parse position-lists. When this function is
181944 ** This function is used to merge two position lists into one. When it is
182124 ** An instance of this function is used to merge together the (potentially
182135 ** This function is used to read a single varint from a buffer. Parameter
182167 ** This function is used to write a single varint to a buffer. The varint
182205 ** This macro is used by various functions that merge doclists. The two
182625 ** Fts3SegReaderPending might segfault, as the data structures used by
182940 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
182947 char *zSql; /* SQL statement used to access %_content */
182977 /* In case the cursor has been used before, clear it now. */
183142 ** This function is the implementation of the xUpdate callback used by
183177 ** as it would also be required by a crisis-merge that used the same input
183316 ** Helper function used by the implementation of the overloaded snippet(),
183323 ** string passed via zFunc is used as part of the error message.
183610 ** Return true if zName is the extension on one of the shadow tables used
183669 ** declared in these files used to retrieve the respective implementations.
183719 /* Allocate and initialize the hash-table used to store tokenizers. */
184055 ** used with fts3EvalPhraseNext() to iterate through the matching docids.
184111 ** This function is used to iterate backwards (from the end to start)
184112 ** through doclists. It is used by this module to iterate through phrase
184258 ** Helper type used by fts3EvalIncrPhraseNext() and incrPhraseTokenNext().
184516 ** This function is used to populate an allocated Fts3TokenAndCost array.
184647 int nOvfl = 0; /* Total overflow pages used by doclists */
185430 Fts3Expr *p; /* Iterator used for several purposes */
185503 ** This function is used by the matchinfo() module to query a phrase
185784 sqlite3_vtab base; /* Base class used by SQLite core */
185789 sqlite3_vtab_cursor base; /* Base class used by SQLite core */
186126 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
186342 ** traditionally used by fts3. Or, if SQLITE_ENABLE_FTS3_PARENTHESIS
186364 ** operator in a similar format to that used by the lemon parser
186405 ** This variable is used by function getNextNode(). When getNextNode() is
186414 int iLangid; /* Language id used with tokenizer */
186939 Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */
187190 /* Link pParent into the free node list. It will be used as an
187485 ** This is the implementation of a scalar SQL function used to test the
187490 ** The first argument, <tokenizer>, is the name of the fts3 tokenizer used
187627 ** This is the implementation of generic hash-tables used in SQLite.
188087 ** used to incrementally tokenize this string is returned in
188288 ** This is the fallback stemmer used when the porter stemmer is
188904 ** designed to be used in concert with the Tcl testing framework. This
189073 ** This function is used for testing only, it is not included in the
189077 ** can be used as designed by the C-code in the queryTokenizer and
189127 ** Set up SQL objects in database db used to access the contents of
189140 ** The third argument to this function, zName, is used as the name
189299 ** used to incrementally tokenize this string is returned in
189480 sqlite3_vtab base; /* Base class used by SQLite core */
189489 sqlite3_vtab_cursor base; /* Base class used by SQLite core */
189760 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
189903 ** of the sub-routines used to merge segments are also used by the query
189936 ** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD
189966 ** and incremental merge operation that takes place. This is used for
189984 ** An instance of the following data structure is used to build doclists
190008 ** An instance of this structure is used to iterate through the terms on
190011 ** of type Fts3SegReader* are also used by code in fts3.c to iterate through
190018 ** Methods used to manipulate Fts3SegReader structures:
190052 /* The following variables are used by fts3SegReaderNextDocid() to iterate
190064 ** An instance of this structure is used to create a segment b-tree in the
190079 char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
190087 ** Type SegmentNode is used by the following three functions to create
190089 ** the leaf nodes). These functions and type are only ever used by code
190112 char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
190164 ** This function is used to obtain an SQLite prepared statement handle
190218 /* This statement is used to determine which level to read the input from
190274 /* Update statements used while promoting segments */
190438 ** in the %_segdir table on disk. This function is used to convert three
190440 ** can be used to query the %_segdir table.
190468 ** Set *ppStmt to a statement handle that may be used to iterate through
190670 ** pending-terms hash-table. The docid used is that currently stored in
190833 ** apVal[0] Not used for INSERT.
190862 /* Locate the statement handle used to insert data into the %_content
191550 ** This is a comparison function used as a qsort() callback when sorting
191572 ** This function is used to allocate an Fts3SegReader that iterates through
191633 ** callback as is used when flushing terms to disk.
192240 /* Save the current term so that it can be used to prefix-compress the next.
192437 ** This function is used after merging multiple segments into a single large
193063 ** order. The contents of level -1 (which is never used, except
193245 int *pNBuf /* Write number of bytes if zBuf[] used here */
193287 sqlite3_stmt *pStmt; /* Statement used to insert the encoding */
193518 ** This function opens a cursor used to read the input data for an
193530 sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */
193573 ** An instance of the following structure is used as a dynamic buffer
193576 ** The function blobGrowBuffer() is used to extend the allocation.
193585 ** This structure is used to build up buffers containing segment b-tree
193611 ** An object of the following type is used to read data from a single
193910 NodeWriter *pLeaf; /* Object used to write leaf nodes */
194099 ** This is used to test if a segment is an "appendable" segment. If it
194291 sqlite3_stmt *pOutputIdx = 0; /* SQL used to find output index */
194340 sqlite3_stmt *pLeafEst = 0; /* SQL used to determine nLeafEst */
194341 sqlite3_stmt *pFirstBlock = 0; /* SQL used to determine first block */
194368 ** to steal the space just allocated. This is also used to identify
194561 Blob block = {0,0,0}; /* Buffer used for any other block */
194565 sqlite3_stmt *pFetch = 0; /* Statement used to fetch segdir */
194803 Fts3MultiSegReader *pCsr; /* Cursor used to read input data */
194804 Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */
194821 sqlite3_stmt *pFindLevel = 0; /* SQL used to determine iAbsLevel */
194973 ** This function used for parameters to merge= and incrmerge=
195759 ** The following types are used as part of the implementation of the
195792 ** This type is used as an fts3ExprIterate() context object while
195806 ** An instance of this structure is used to manage a pair of buffers, each
195821 ** of the following structure is used to accumulate those values while the
195925 ** This function is used to help iterate through a position-list. A position
195990 int iPhrase = 0; /* Variable used as the phrase counter */
195996 ** This is an fts3ExprIterate() callback used while loading the doclists
196172 ** This function is an fts3ExprIterate() callback used by fts3BestSnippet().
196463 const char *ZDUMMY; /* Dummy argument used with tokenizer */
196464 int DUMMY1 = -1; /* Dummy argument used with tokenizer */
196473 ** that needs to know whether or not the tokenizer is being used for
196478 ** If a tokenizer is used directly by any code outside of FTS, this
196538 ** This function is used to count the entries in a column-list (a
196624 ** fts3ExprIterate() callback used to collect the "global" matchinfo stats
196662 ** fts3ExprIterate() callback used to collect the "local" part of the
196782 ** An instance of the following structure is used to store state while
196791 char *pRead; /* Cursor used to iterate through aDoclist */
197083 ** allocate the array used to accumulate the matchinfo data and
197262 ** This function is an fts3ExprIterate() callback used by sqlite3Fts3Offsets().
197331 const char *ZDUMMY; /* Dummy argument used with xNext() */
197332 int NDUMMY = 0; /* Dummy argument used with xNext() */
197726 ** used to incrementally tokenize this string is returned in
197894 ** codepoint in the range. The least significant 10 bits are used to store
198309 ** that can be and is used to create strings other than JSON.
198315 u64 nUsed; /* Bytes of zBuf[] currently used */
198372 u32 nNode; /* Number of slots of aNode[] used */
199243 ** Magic number used for the JSON parse cache in sqlite3_get_auxdata()
199602 ** SQL functions used for testing and debugging
201050 /* The following macro is used to suppress compiler warnings.
201074 ** used.
201117 ** linked together via the pointer normally used for hash chains -
201217 ** used to cache the RtreeNode for RtreeCursor.sPoint. The remaining
201234 int nPoint; /* Number of slots used in aPoint[] */
201297 ** are used in the cursor for contraints such as x=NULL (RTREE_FALSE) or
201368 /* What version of GCC is being used. 0 means GCC is not being used .
201433 /* What version of MSVC is being used. 0 means MSVC is not being used */
202908 ** If strategy 1 is used, then idxStr is not meaningful. If strategy
202909 ** 2 is used, idxStr is formatted to contain 2 bytes for each
202910 ** constraint used. The first two bytes of idxStr correspond to
203275 ** The aSpare array is used as temporary working space by the
203339 ** maximum used to break ties.
203341 ** The aSpare array is used as temporary working space by the
203669 ** rowid of the row to delete, which can be used to find the leaf on which
203838 /* Allocate the buffers used by this operation. The allocation is
204412 ** Return true if zName is the extension on one of the shadow tables used
204603 ** determine the node-size used by the rtree table being created or connected
204796 ** human readable strings. This can be used for debugging and analysis.
204890 sqlite3_stmt *pGetNode; /* Statement used to retrieve nodes */
205014 ** This function is used to check that the %_parent (if bLeaf==0) or %_rowid
205270 /* Finalize SQL statements used by the integrity-check */
205833 ** This routine can also be used to detect polygons that rotate in
206219 /* Objects used by the overlap algorihm. */
207435 ** This lookup table is used to help decode the first byte of
207801 ** This scalar function is used to add ICU collation based collation
207998 ** used to incrementally tokenize this string is returned in
208300 ** CREATE INDEX commands. This extension allows it to be used to improve
208397 ** Either of the following input table schemas may be used:
208417 ** other columns are not used.
208458 ** format used by the fossil source-code management system. In this case
208623 ** Configure a limit for the amount of temp space that may be used by
208639 ** Return the current amount of temp file space, in bytes, currently used by
208815 ** function may be used to register a callback that the RBU module will invoke
208872 ** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack
208930 ** The rbu_state table is used to save the state of a partially applied
208961 ** header created by recovering the *-wal file. This is used to detect
209041 char *zMask; /* Copy of update mask used with pUpdate */
209052 ** An iterator of this type is used to iterate through all objects in
209104 /* Last UPDATE used (for PK b-tree updates only), or NULL. */
209208 /* The following state variables are used as part of the incremental
209232 ** sqlite3rbu_create_vfs(). It is used to track the total amount of temp
209233 ** space used by the RBU handle.
209287 ** are used to implement the scalar SQL function rbu_fossil_delta().
209677 /* Free any SQLite statements used while processing the previous object */
210297 ** constructs a WHERE clause that can be used to extract the remaining
210359 ** it, then composes and returns an expression that can be used in a WHERE
210469 ** This function is used to create a SELECT list (the list of SQL
210471 ** used to read from an data_xxx or rbu_tmp_xxx table while updating the
210473 ** second argument. A "PRAGMA index_xinfo = <idxname>" statement is used
210636 ** Return an expression that can be used in a WHERE clause to match the
210695 ** an UPDATE statement used to update the table object that the iterator
210831 ** This function creates the second imposter table used when writing to
210839 ** used to access that PK index. For example, if the target table is
210969 ** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table.
211161 /* Create the imposter table used to write to this index. */
211387 ** be used to update the imposter table for the main table b-tree of the
212651 ** argument. This VFS will be used unless the call to sqlite3rbu_open()
212984 ** Return the database handle used by pRbu.
214199 ** The dbstat virtual table is used to extract low-level storage
214269 /* Forward reference to data structured used in this module */
214307 int iDb; /* Schema used for this query */
214407 ** used.
214526 /* Resize the space-used counters inside of the cursor */
214925 int iArg = 0; /* Count of argv[] parameters used so far */
215102 ** The sqlite_dbpage virtual table is used to read or write whole raw
215103 ** pages of the database file. The pager interface is used so that
215302 ** idxStr is not used
215533 ** Minimum chunk size used by streaming versions of functions.
215576 ** Instances of this structure are used to build strings or binary records.
215585 ** An object of this type is used internally as an abstraction for
215651 ** used in SQLite database files. This format is used as part of the
215777 ** The format used for a rebase blob is very similar to that used for
215871 ** This function is used to serialize the contents of value pValue (see
215976 ** This macro is used to calculate hash key values for data structures. In
215980 ** then be used as follows:
215987 ** In practice, the data structures this macro is used for are the primary
216163 SessionTable *pTab, /* Table used for PK definition */
216211 u8 *a1 = aLeft; /* Cursor used to iterate through aLeft */
216212 u8 *a2 = aRight; /* Cursor used to iterate through aRight */
216234 ** This is a helper function used by sessionMergeUpdate().
216282 ** This function is used by changeset_concat() to merge two UPDATE changes
216369 u8 *a = pChange->aRecord; /* Cursor used to scan change record */
216431 ** If required, grow the hash table used to store changes on table pTab
217525 ** always fail. It is used here to ensure that this routine can always
218363 ** Create an iterator used to iterate through the contents of a changeset.
218875 ** sqlite3changeset_new() and old() APIs may be used to query for values.
219005 ** The following two macros are used internally. They are similar to the
221440 ** This function may be quite inefficient if used with an FTS5 table
221463 ** This API can be quite slow if used with an FTS5 table created with the
221479 ** This API can be quite slow if used with an FTS5 table created with the
221489 ** This API function is used to query the FTS table for phrase iPhrase
221499 ** function may be used to access the properties of each matched row.
221551 ** This function is used to retrieve the total number of rows in the table.
221557 ** This function is used, along with type Fts5PhraseIter and the xPhraseNext
221574 ** modify this structure directly - it should only be used as shown above
221578 ** This API can be quite slow if used with an FTS5 table created with the
221591 ** APIs are used to iterate through the set of columns in the current row
221603 ** This API can be quite slow if used with an FTS5 table created with the
221612 ** significantly more efficient than those alternatives when used with
221670 ** This function is used to allocate and initialize a tokenizer instance.
221678 ** tokenizer name as part of the CREATE VIRTUAL TABLE statement used
222026 ** is used for assert() conditions that are true only if it can be
222056 ** then an object of the following type is used to record the set of columns.
222059 ** This object is used by fts5_expr.c and fts5_index.c.
222091 ** used as part of an SQL statement it needs to be quoted appropriately.
222104 ** This is only used for debugging. If set to false, any prefix indexes
222132 int pgsz; /* Approximate page size used in %_data */
222237 /* Variables used only by sqlite3Fts5PoslistIterXXX() functions. */
222275 /* Bucket of terms object used by the integrity-check in offsets=0 mode. */
222303 ** Values used as part of the flags argument passed to IndexQuery().
222310 /* The following are used internally by the fts5_index.c module. They are
222375 ** This interface is used by the fts5vocab module.
222495 sqlite3_vtab base; /* Base class used by SQLite core */
222683 ** The fts5_expr.c API above this point is used by the other hand-written
222882 ** fts5YYCODETYPE is the data type used to store the integer codes
222884 ** "unsigned char" is used if there are fewer than
222886 ** fts5YYNOCODE is a number of type fts5YYCODETYPE that is not used for
222890 ** values which should be used if the original symbol
222892 ** be used as identifiers, for example.
222893 ** fts5YYACTIONTYPE is the data type used for "action codes" - numbers
222896 ** sqlite3Fts5ParserFTS5TOKENTYPE is the data type used for minor type for terminal
222905 ** fts5YYMINORTYPE is the data type used for all minor types.
222989 /* Next are the tables used to determine what action to take based on the
222990 ** current state and lookahead token. These tables are used to implement
223019 ** The (A) formula is preferred. The B formula is used instead if
223024 ** a reduce action) then the fts5yy_reduce_ofst[] array is used in place of
223102 ** This feature can be used, for example, to cause some keywords in a language
223120 ** the information used by the action routines in the grammar.
223339 ** A pointer to the function used to allocate memory.
223342 ** A pointer to a parser. This pointer is used in subsequent calls
223360 ** a pointer to the value to be deleted. The code used to do the
223379 ** which appear on the RHS of the rule, but which are *not* used
223460 void (*freeProc)(void*) /* Function used to reclaim memory */
223492 ** (1) has not been used by the parser, and
224301 ** Object used to iterate through all "coalesced phrase instances" in
224429 ** Tokenizer callback used by implementation of highlight() function.
224563 ** This function is an xTokenize() callback used by the auxiliary snippet()
224820 double *aFreq; /* Array used to calculate phrase freq. */
224824 ** Callback used by fts5Bm25GetData() to count the number of rows in the
225357 ** used by the fts5_hash.c module. This is not important for correct
226454 ** used as if it has the same signature as the xNext() methods themselves.
228030 ** Callback for tokenizing terms used by ParseTerm().
228578 ** This function is used when parsing LIKE or GLOB patterns against
229211 ** This function is used to access the current position list for phrase
229239 ** At present this function is only used for detail=col and detail=none
229466 ** This file contains the implementation of an in-memory hash table used
230042 ** the doclist. This is used to speed up seek operations, and merges of
230218 #define FTS5_AVERAGES_ROWID 1 /* Rowid used for the averages record */
230222 ** Macros determining the rowids used by segment leaves and dlidx leaves
230299 /* State used by the fts5DataXXX() functions. */
230347 ** An object of type Fts5SegWriter is used to write to segments.
230424 ** These are used if the FTS5_SEGITER_REVERSE flag is set.
230452 /* The following are only used if the FTS5_SEGITER_REVERSE flag is set. */
230532 ** An instance of the following type is used to iterate through the contents
230646 ** rollback since it was last used. In this case a new blob handle
231146 ** function is only ever used as part of assert() conditions.
231765 /* This happens if the segment is being used as an input to an incremental
231925 ** This version of fts5SegIterNext() is only used by reverse iterators.
231958 ** This version of fts5SegIterNext() is only used if detail=none and the
232586 ** This function is used as part of the big assert() procedure implemented by
232630 ** statement used to verify that the contents of the pIter->aFirst[] array
233277 ** xSetOutputs callback used by detail=none tables.
233286 ** xSetOutputs callback used by detail=full and detail=col tables when no
233311 ** xSetOutputs callback used when the Fts5Colset object has nCol==0 (match
233320 ** xSetOutputs callback used by detail=col when there is a column filter
233333 ** xSetOutputs callback used when:
233380 ** xSetOutputs callback used by detail=full when there is a column filter.
233443 ** The new object will be used to iterate through data in structure pStruct.
233645 ** id must be between 1 and 65335 inclusive, and must not be used by
234210 ** Iterator pIter was used to iterate through the input segments of on an
235240 Fts5Iter *p1 = 0; /* Iterator used to gather data from index */
235584 ** evaluate the prefix query using the main FTS index. This is used
236234 Fts5Buffer poslist = {0,0,0}; /* Buffer used to hold a poslist */
236242 Fts5Buffer term = {0,0,0}; /* Buffer used to hold most recent term */
236500 ** only ever used with detail=none tables.
236502 ** Buffer (pData/nData) contains a doclist in the format used by detail=none
236892 ** structure is used to record the current transaction state. This information
236893 ** is not required, but it is used in the assert() statements executed by
236903 ** registered with a database handle. It is used to store pointers to
236984 ** These variables are only used for FTS5_PLAN_MATCH cursors. Assuming the
236996 sqlite3_vtab_cursor base; /* Base class used by SQLite core */
237006 sqlite3_stmt *pStmt; /* Statement used to read %_content */
237024 /* Cache used by auxiliary functions xInst() and xInstCount() */
237283 ** extension is currently being used by a version of SQLite too old to
237332 ** flags used to encode the ORDER BY clause:
237338 ** idxStr is used to encode data from the WHERE clause. For each argument
237874 ** the text passed to the MATCH operator are used as the special query
237908 ** Search for an auxiliary function named zName that can be used with table
238034 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
238165 ** (pCursor) is used to execute the query issued by function
238357 "'delete-all' may only be used with a "
238367 "'rebuild' may not be used with a contentless fts5 table"
238431 ** This function is the implementation of the xUpdate callback used by
239628 ** Return true if zName is the extension on one of the shadow tables used
239716 ** The following functions are used to register the module with SQLite. If
240122 ** Tokenization callback used when inserting tokens into the FTS index.
240424 ** Allocate a new rowid. This is used for "external content" tables when
240496 Fts5Buffer buf; /* Buffer used to build up %_docsize blob */
240557 ** Context object used by sqlite3Fts5StorageIntegrity().
240571 ** Tokenization callback used by integrity check.
240748 ** Obtain an SQLite statement handle that may be used to read data from the
243184 /* A 32-bit varint is used to store size information in btrees.
243206 ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
243532 /* These are used by 'col' tables only */
243537 /* Output values used by all tables. */
243555 ** Bits for the mask used as the idxNum value by xBestIndex/xFilter.
244066 sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */