Lines Matching +full:unmanaged +full:- +full:versions +full:- +full:check
2 ** 2001-09-15
13 ** presents to client programs. If a C-function, structure, datatype,
24 ** The official C-language API documentation for SQLite is derived
71 ** These no-op macros are used in front of interfaces to mark those
73 ** should not use deprecated interfaces - they are supported for backwards
97 ** CAPI3REF: Compile-Time Library Version Numbers
113 ** <a href="http://www.fossil-scm.org/">Fossil configuration management
115 ** a string which identifies a particular check-in of SQLite
117 ** string contains the date and time of the check-in (UTC) and a SHA1
118 ** or SHA3-256 hash of the entire source tree. If the source code has
128 #define SQLITE_SOURCE_ID "2021-04-02 15:20:15 5d4c65779dab868b285519b19e4cf9d451d50c6048f06f65…
131 ** CAPI3REF: Run-Time Library Version Numbers
168 ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
177 ** returning the N-th compile time option string. ^If N is out of range,
202 ** [SQLITE_THREADSAFE] compile-time option being set to 0.
220 ** This interface only reports on the compile-time mutex setting
226 ** sqlite3_threadsafe() function shows only the compile-time setting of
227 ** thread safety, not any run-time changes to that setting made by
252 ** CAPI3REF: 64-Bit Integer Types
255 ** Because there is no cross-platform way to specify 64-bit integer types
256 ** SQLite includes typedefs for 64-bit signed and unsigned integers.
263 ** between -9223372036854775808 and +9223372036854775807 inclusive. ^The
286 ** substitute integer for floating-point.
328 ** argument is a harmless no-op.
341 ** CAPI3REF: One-Step Query Execution Interface
349 ** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
350 ** semicolon-separate SQL statements passed into its 2nd argument,
372 ** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
417 ** New error codes may be added in future versions of SQLite.
422 /* beginning-of-error-codes */
453 /* end-of-error-codes */
461 ** these result codes are too coarse-grained. They do not provide as
463 ** address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8]
606 ** read-only media and cannot be changed even by processes with
664 ** (Third-party VFS implementations might also make the distinction
699 ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
732 ** locking strategy (for example to use dot-file locks), to inquire
779 ** fails to zero-fill short reads might seem to work. However,
780 ** failure to zero-fill short reads will eventually lead to
826 ** compile-time option is used.
837 ** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that
839 ** of the in-memory database. The argument is a pointer to a [sqlite3_int64].
849 ** point to an integer (type int) containing the new chunk-size to use
851 ** chunks (say 1MB at a time), may reduce file-system fragmentation and
862 ** the [rollback journal] or the [write-ahead log]) for a particular database
875 ** this file-control is NULL. However, if the database file is being synced
876 ** as part of a multi-database commit, the argument points to a nul-terminated
877 ** string containing the transactions super-journal file name. VFSes that
894 ** anti-virus programs. By default, the windows VFS will retry file read,
920 ** WAL mode. If the integer is -1, then it is overwritten with the current
925 ** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting
929 ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
930 ** mode. If the integer is -1, then it is overwritten with the current
931 ** zero-damage mode setting.
942 ** final bottom-level VFS are written into memory obtained from
946 ** all file-control actions, there is no guarantee that this will actually
948 ** pointer in case this file-control is not implemented. This file-control
952 ** ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level
956 ** to a pointer to the top-level VFS.)^
958 ** upper-most shim only.
975 ** VFS has handled the PRAGMA itself and the parser generates a no-op
977 ** of the result string if the string is non-NULL.
983 ** it is able to override built-in [PRAGMA] statements.
987 ** file-control may be invoked by SQLite on the database file handle
989 ** to the connection's busy-handler callback. The argument is of type (void**)
990 ** - an array of two (void *) values. The first (void *) actually points
992 ** busy-handler, this function should be invoked with the second (void *) in
993 ** the array as the only argument. If it returns non-zero, then the operation
998 ** ^Applications can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control
1008 ** maximum number of bytes that will be used for memory-mapped I/O.
1014 ** file-control is used internally to implement [PRAGMA mmap_size].
1020 ** The argument is a zero-terminated string. Higher layers in the
1022 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
1047 ** Applications should <em>not</em> use this file-control.
1096 ** The parameter is a pointer to a 32-bit signed integer that contains
1097 ** the value that M is to be set to. Before returning, the 32-bit signed
1102 ** a database file. The argument is a pointer to a 32-bit unsigned integer.
1128 ** file to the database file, but before the *-shm file is updated to
1214 ** may increase again in future versions of SQLite.
1227 ** in a thread-safe way. The [sqlite3_vfs_find()] interface
1245 ** consist of a single "-" character followed by no more than
1246 ** 11 alphanumeric and/or "-" characters.
1261 ** If xOpen() opens a file read-only then it sets *pOutFlags to
1281 ** the open of a journal file a no-op. Writes to this journal would
1282 ** also be no-ops, and any attempt to read the journal would return
1284 ** file will be doing page-aligned sector reads and writes in a random
1323 ** flag is never actually used and is not implemented in the built-in
1326 ** non-zero error code if there is an I/O error or if the name of
1328 ** is returned, then non-zero or zero is written into *pResOut to indicate
1342 ** of good-quality randomness into zOut. The return value is
1350 ** a 24-hour day).
1376 void *pAppData; /* Pointer to application-specific data */
1396 ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
1403 ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
1404 ** New fields may be appended in future versions. The iVersion
1486 ** are harmless no-ops.)^
1491 ** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
1514 ** compile-time option, then the automatic calls to sqlite3_initialize()
1523 ** The sqlite3_os_init() routine does operating-system specific
1539 ** (using the [SQLITE_OS_OTHER=1] compile-time
1541 ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied
1570 ** implementation of an application-defined [sqlite3_os_init()].
1580 ** then this routine returns a non-zero [error code].
1594 ** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
1607 ** and low-level memory allocation routines.
1619 ** Note that SQLite comes with several [built-in memory allocators]
1624 ** memory allocator that simulates memory out-of-memory conditions in
1687 ** should check the return code from [sqlite3_config()] to make sure that
1689 ** non-zero [error code] if a discontinued or unsupported configuration option
1695 ** [threading mode] to Single-thread. In other words, it disables
1698 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1700 ** value of Single-thread and so [sqlite3_config()] will return
1706 ** [threading mode] to Multi-thread. In other words, it disables
1710 ** are enabled so that SQLite will be safe to use in a multi-threaded
1713 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1714 ** it is not possible to set the Multi-thread [threading mode] and
1729 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1738 ** alternative low-level memory allocation routines to be used in place of
1766 ** disabled, the following SQLite interfaces become non-operational:
1787 ** This configuration option is a no-op if an application-defined page
1790 ** 8-byte aligned memory (pMem), the size of each page cache line (sz),
1798 ** argument must be either a NULL pointer or a pointer to an 8-byte
1805 ** ^If pMem is NULL and N is non-zero, then each database connection
1808 ** of -1024*N bytes if N is negative, . ^If additional
1821 ** An 8-byte aligned pointer to the memory,
1828 ** The first pointer (the memory pointer) must be aligned to an 8-byte
1836 ** The argument specifies alternative low-level mutex routines to be used
1840 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1853 ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1886 ** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
1888 ** passed through as the first parameter to the application-defined logger
1896 ** In a multi-threaded application, the application-defined logger
1901 ** If non-zero, then URI handling is globally enabled. If the parameter is zero,
1918 ** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
1919 ** if that compile-time option is omitted.
1924 ** without change even with newer versions of SQLite.
1929 ** They are retained for backwards compatibility but are now no-ops.
1935 ** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
1951 ** <dd>^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values
1958 ** compile-time maximum mmap size set by the
1959 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
1961 ** changed to its compile-time default.
1966 ** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro
1967 ** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
1983 ** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched
1992 ** becomes the [statement journal] spill-to-disk threshold.
1995 ** Or if the threshold is -1, statement journals are always held
2001 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
2006 ** of type (int) - the new value of the sorter-reference size threshold.
2010 ** of a table column that its values are likely to be very large - larger
2011 ** than the configured sorter-reference size threshold - then a reference
2017 ** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
2022 ** [sqlite3_int64] parameter which is the default maximum size for an in-memory
2025 ** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this
2027 ** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that
2028 ** compile-time option is not set, then the default maximum is 1073741824.
2044 #define SQLITE_CONFIG_PCACHE 14 /* no-op */
2045 #define SQLITE_CONFIG_GETPCACHE 15 /* no-op */
2069 ** should check the return code from [sqlite3_db_config()] to make sure that
2071 ** non-zero [error code] if a discontinued or unsupported configuration option
2087 ** must be aligned to an 8-byte boundary. ^If the second argument to
2123 ** triggers in the main database schema or in the schemas of ATTACH-ed
2140 ** views in the main database schema or in the schemas of ATTACH-ed
2147 ** [FTS3] full-text search engine extension.
2162 ** C-API [sqlite3_load_extension()] and the SQL function [load_extension()].
2164 ** When the first argument to this interface is 1, then only the C-API is
2166 ** this interface is 0, then both the C-API and the SQL function are disabled.
2167 ** If the first argument is -1, then no changes are made to state of either the
2168 ** C-API or the SQL function.
2191 ** is an integer - positive to disable checkpoints-on-close, or zero (the
2194 ** into which is written 0 or 1 to indicate whether checkpoints-on-close
2195 ** have been disabled - 0 if they are not disabled, 1 if they are.
2218 ** behavior. The first parameter passed to this operation is an integer -
2222 ** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if
2275 ** behaves as it did prior to [version 3.24.0] (2018-06-04). See the
2284 ** the legacy [double-quoted string literal] misfeature for DML statements
2286 ** default value of this setting is determined by the [-DSQLITE_DQS]
2287 ** compile-time option.
2293 ** the legacy [double-quoted string literal] misfeature for DDL statements,
2295 ** default value of this setting is determined by the [-DSQLITE_DQS]
2296 ** compile-time option.
2308 ** CHECK constraints, DEFAULT clauses, expression indexes,
2323 ** created database file to have a schema format version number (the 4-byte
2327 ** newly created databases are generally not understandable by SQLite versions
2337 ** not considered a bug since SQLite versions 3.3.0 and earlier do not support
2377 ** has a unique 64-bit signed
2455 ** considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
2477 ** any changes performed by sub-triggers, as the sqlite3_changes()
2478 ** value will be saved and restored after each sub-trigger has run.)^
2540 ** CAPI3REF: Interrupt A Long-Running Query
2546 ** or Ctrl-C where the user wants a long query operation to halt
2571 ** SQL statements is a no-op and has no effect on SQL statements
2579 ** These routines are useful during command-line input to determine if the
2585 ** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within
2600 ** then the return value from sqlite3_complete16() will be non-zero
2603 ** The input to [sqlite3_complete()] must be a zero-terminated
2604 ** UTF-8 string.
2606 ** The input to [sqlite3_complete16()] must be a zero-terminated
2607 ** UTF-16 string in native byte order.
2614 ** KEYWORDS: {busy-handler callback} {busy handler}
2636 ** ^If the callback returns non-zero, then another attempt
2712 ** A result table is an array of pointers to zero-terminated UTF-8 strings.
2714 ** to zero-terminated strings that contain the names of the columns.
2716 ** in NULL pointers. All other values are in their UTF-8 zero-terminated
2728 ** -----------------------
2750 ** semicolon-separated SQL statements in the zero-terminated UTF-8
2782 ** These routines are work-alikes of the "printf()" family of functions
2786 ** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]).
2787 ** See the [built-in printf()] documentation for details.
2810 ** guarantees that the buffer is always zero-terminated. ^The first
2813 ** written will be n-1 characters.
2817 ** See also: [built-in printf()], [printf() SQL function]
2829 ** does not include operating-system specific [VFS] implementation. The
2840 ** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead
2841 ** of a signed 32-bit integer.
2846 ** a no-op if is called with a NULL pointer. Passing a NULL pointer
2851 ** might result if sqlite3_free() is called with a non-NULL pointer that
2871 ** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead
2872 ** of a 32-bit signed integer.
2887 ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
2911 ** routines, which form the built-in memory allocation subsystem.
2916 ** value of [sqlite3_memory_used()] since the high-water mark
2923 ** ^The memory high-water mark is reset to the current value of
2926 ** by [sqlite3_memory_highwater(1)] is the high-water mark
2933 ** CAPI3REF: Pseudo-Random Number Generator
2935 ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
2938 ** the built-in random() and randomblob() SQL functions. This interface allows
2949 ** non-NULL P then the pseudo-randomness is generated
2956 ** CAPI3REF: Compile-Time Authorization Callbacks
2987 ** to the callback are either NULL pointers or zero-terminated strings
3015 ** user-entered SQL is being [sqlite3_prepare | prepared] that
3034 ** statement might be re-prepared during [sqlite3_step()] due to a
3080 ** is the name of the inner-most trigger or view that is responsible for
3082 ** top-level SQL code.
3132 ** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
3136 ** contain a UTF-8 SQL comment that identifies the trigger.)^
3138 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
3143 ** the original statement text and an estimate of wall-clock time
3147 ** digits in the time are meaningless. Future versions of SQLite
3163 ** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of
3185 ** interface by using the X argument when X begins with "--" and invoking
3192 ** X argument points to a 64-bit integer which is the estimated of
3222 ** M argument should be the bitwise OR-ed combination of
3272 ** ^If the progress callback returns non-zero, the operation is
3289 ** filename argument. ^The filename argument is interpreted as UTF-8 for
3290 ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
3301 ** ^The default encoding will be UTF-8 for databases created using
3303 ** created using sqlite3_open16() will be UTF-16 in the native byte order.
3317 ** <dd>The database is opened in read-only mode. If the database does not
3339 ** <dd>The database will be opened as an in-memory database. The database
3340 ** is named by the "filename" argument for the purposes of cache-sharing,
3345 ** <dd>The new database connection will use the "multi-thread"
3381 ** ^If the filename is ":memory:", then a private, temporary in-memory database
3382 ** is created for the connection. ^This in-memory database will vanish when
3383 ** the database connection is closed. Future versions of SQLite might
3390 ** on-disk database will be created. ^This private database will be
3400 ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
3423 ** SQLite and its built-in [VFSes] interpret the
3438 ** ^If "ro" is specified, then the database is opened for read-only
3441 ** "rw", then the database is opened for read-write (but not create)
3445 ** set to "memory" then a pure [in-memory database] that never reads
3472 ** read-only media. ^When immutable is set, SQLite assumes that the
3474 ** privilege, and so the database is opened read-only and all locking
3483 ** error. Future versions of SQLite might understand additional query
3499 ** <tr><td style="white-space:nowrap">
3503 ** necessary - space characters can be used literally
3506 ** Open file "data.db" in the current directory for read-only access.
3507 ** Regardless of whether or not shared-cache mode is enabled by
3509 ** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
3510 ** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
3511 ** that uses dot-files in place of posix advisory locking.
3519 ** percent sign - "%" - followed by exactly two hexadecimal digits
3521 ** URI filename are interpreted, they are encoded using UTF-8 and all
3523 ** corresponding octet. If this process generates an invalid UTF-8 encoding,
3527 ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3529 ** characters must be converted to UTF-8 prior to passing them into
3539 const char *filename, /* Database filename (UTF-8) */
3543 const void *filename, /* Database filename (UTF-16) */
3547 const char *filename, /* Database filename (UTF-8) */
3557 ** that check if a database file was a URI that contained a specific query
3569 ** undefined and probably undesirable. Older versions of SQLite were
3570 ** more tolerant of invalid F parameters than newer versions.
3584 ** case or if the value begins with a non-zero number. The
3592 ** 64-bit signed integer and returns that integer, or D if P does not
3597 ** the value) of the N-th query parameter for filename F, or a NULL
3599 ** parameters minus 1. The N value is zero-based so N should be 0 to obtain
3658 ** ^If X is the name of a rollback or WAL-mode journal file that is
3664 ** only. It is not a general-purpose interface.
3708 ** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op.
3744 ** change the value of the error code. The error-code preserving
3754 ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
3755 ** text that describes the error, as either UTF-8 or UTF-16 respectively.
3761 ** ^The sqlite3_errstr() interface returns the English-language text
3762 ** that describes the [result code], as UTF-8.
3798 ** The life-cycle of a prepared statement object usually goes like this:
3813 ** CAPI3REF: Run-time Limits
3826 ** set at compile-time by a C preprocessor macro called
3835 ** simply invoke this interface with the third parameter set to -1.
3837 ** Run-time limits are intended for use in applications that manage
3850 ** New run-time limit categories may be added in future releases.
3855 ** CAPI3REF: Run-Time Limit Categories
3859 ** that can be lowered at run-time using [sqlite3_limit()].
3941 ** deplete the limited store of lookaside memory. Future versions of
3945 ** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
3968 ** To execute an SQL statement, it must first be compiled into a byte-code
3977 ** The use of the UTF-8 interfaces is preferred, as SQLite currently
3978 ** does all parsing using UTF-8. The UTF-16 interfaces are provided
3979 ** as a convenience. The UTF-16 interfaces work by converting the
3980 ** input text into UTF-8, then invoking the corresponding UTF-8 interface.
3987 ** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(),
3989 ** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(),
3990 ** and sqlite3_prepare16_v3() use UTF-16.
3996 ** If the caller knows that the supplied string is nul-terminated, then
3999 ** the nul-terminator.
4049 ** ^The specific value of a WHERE-clause [parameter] might influence the
4050 ** choice of query plan if the parameter is the left-hand side of a [LIKE]
4052 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
4064 const char *zSql, /* SQL statement, UTF-8 encoded */
4071 const char *zSql, /* SQL statement, UTF-8 encoded */
4078 const char *zSql, /* SQL statement, UTF-8 encoded */
4086 const void *zSql, /* SQL statement, UTF-16 encoded */
4093 const void *zSql, /* SQL statement, UTF-16 encoded */
4100 const void *zSql, /* SQL statement, UTF-16 encoded */
4111 ** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8
4115 ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
4118 ** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8
4134 ** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of
4135 ** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time
4153 ** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
4157 ** Note that [application-defined SQL functions] or
4161 ** change the database file through side-effects:
4201 ** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
4238 ** sqlite3_value object. If SQLite is compiled to be single-threaded
4249 ** implementation of [application-defined SQL functions] are protected.
4265 ** is always first parameter to [application-defined SQL functions].
4266 ** The application-defined SQL function implementation will pass this
4316 ** it should be a pointer to well-formed UTF8 text.
4318 ** it should be a pointer to well-formed UTF16 text.
4320 ** it should be a pointer to a well-formed unicode string that is
4324 ** [[byte-order determination rules]] ^The byte-order of
4325 ** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)
4342 ** If a non-negative fourth parameter is provided to sqlite3_bind_text()
4359 ** information is in static, unmanaged space and does not need to be freed.
4378 ** ^A negative value for the zeroblob results in a zero-length BLOB.
4380 ** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in
4452 ** the name of the N-th [SQL parameter] in the [prepared statement] P.
4463 ** ^If the value N is out of range or if the N-th parameter is
4465 ** always in UTF-8 encoding even if the named parameter was
4466 ** originally specified as UTF-16 in [sqlite3_prepare16()],
4483 ** name must be given in UTF-8 even if the original statement
4484 ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or
4525 ** interface returns a pointer to a zero-terminated UTF-8 string
4526 ** and sqlite3_column_name16() returns a pointer to a zero-terminated
4527 ** UTF-16 string. ^The first parameter is the [prepared statement]
4538 ** (for example during a conversion from UTF-8 to UTF-16) then a
4557 ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
4566 ** ^The names returned are the original un-aliased names of the
4572 ** ^The left-most column is column 0 for these routines.
4581 ** UTF-16 encoded strings and the other functions return UTF-8.
4584 ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
4608 ** ^The returned string is always UTF-8 encoded.
4621 ** ^SQLite uses dynamic run-time typing. ^So just because a column
4671 ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
4687 ** For all versions of SQLite up to and including 3.6.23.1, a call to
4697 ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
4727 ** will return non-zero if previous call to [sqlite3_step](P) returned
4729 ** where it always returns zero since each step of that multi-step
4743 ** <li> 64-bit signed integer
4744 ** <li> 64-bit IEEE floating point number
4777 ** <tr><td><b>sqlite3_column_int</b><td>→<td>32-bit INTEGER result
4778 ** <tr><td><b>sqlite3_column_int64</b><td>→<td>64-bit INTEGER result
4779 ** <tr><td><b>sqlite3_column_text</b><td>→<td>UTF-8 TEXT result
4780 ** <tr><td><b>sqlite3_column_text16</b><td>→<td>UTF-16 TEXT result
4785 ** or a UTF-8 TEXT result in bytes
4787 ** <td>→ <td>Size of UTF-16
4832 ** versions of SQLite may change the behavior of sqlite3_column_type()
4839 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
4841 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
4842 ** the string to UTF-8 and then returns the number of bytes.
4844 ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
4848 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
4850 ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
4851 ** the string to UTF-16 and then returns the number of bytes.
4853 ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
4864 ** even empty strings, are always zero-terminated. ^The return
4865 ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
4877 ** [application-defined SQL functions] or [virtual tables], not within
4878 ** top-level application code.
4896 ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT
4917 ** sqlite3_column_text16() is called. A zero-terminator might
4919 ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
4921 ** to UTF-16.</li>
4922 ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
4924 ** to UTF-8.</li>
4927 ** ^Conversions between UTF-16be and UTF-16le are always done in place and do
4958 ** fail if an out-of-memory error occurs during a format conversion.
4959 ** Only the following subset of interfaces are subject to out-of-memory
4970 ** If an out-of-memory error occurs, then the return value from these
4972 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
5006 ** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
5021 ** object back to its initial state, ready to be re-executed.
5060 ** connection then application-defined SQL functions must be added
5064 ** redefined. ^The length of the name is limited to 255 bytes in a UTF-8
5065 ** representation, exclusive of the zero-terminator. ^Note that the name
5066 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
5072 ** aggregate takes. ^If this parameter is -1, then the SQL function or
5075 ** parameter is less than -1 or greater than 127 then the behavior is
5094 ** deterministic. The built-in [random()] SQL function is an example of a
5101 ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions,
5104 ** <span style="background-color:#ffff90;">
5106 ** all application-defined SQL functions that do not need to be
5107 ** used inside of triggers, view, CHECK constraints, or other elements of
5121 ** pointers to C-language functions that implement the SQL function or
5131 ** C-language callbacks that implement the new function. xStep and xFinal
5132 ** must both be non-NULL. xValue and xInverse may either both be NULL, in
5134 ** non-NULL, in which case the new function may be used as either an aggregate
5137 ** [user-defined window functions|available here].
5152 ** SQL function is used. ^A function implementation with a non-negative
5161 ** ^Built-in functions may be overloaded by new application-defined functions.
5163 ** ^An application-defined function is permitted to call other
5218 #define SQLITE_UTF8 1 /* IMP: R-37514-35566 */
5219 #define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */
5220 #define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */
5247 ** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in
5248 ** schema structures such as [CHECK constraints], [DEFAULT clauses],
5251 ** for all [application-defined SQL functions], and especially for functions
5252 ** that have side-effects or that could potentially leak sensitive
5270 ** schema structures such as [CHECK constraints], [DEFAULT clauses],
5272 ** the function is tagged with SQLITE_INNOCUOUS. Most built-in functions
5274 ** SQLITE_INNOCUOUS flag for application-defined functions unless the
5276 ** security-adverse side-effects and information-leaks.
5281 ** [sqlite3_value_subtype()] to inspect the sub-types of its arguments.
5283 ** functions. However, if it is not specified for a user-defined window
5284 ** function, then any sub-types belonging to arguments passed to the window
5323 ** <tr><td><b>sqlite3_value_int</b><td>→<td>32-bit INTEGER value
5324 ** <tr><td><b>sqlite3_value_int64</b><td>→<td>64-bit INTEGER value
5326 ** <tr><td><b>sqlite3_value_text</b><td>→<td>UTF-8 TEXT value
5327 ** <tr><td><b>sqlite3_value_text16</b><td>→<td>UTF-16 TEXT value in
5329 ** <tr><td><b>sqlite3_value_text16be</b><td>→<td>UTF-16be TEXT value
5330 ** <tr><td><b>sqlite3_value_text16le</b><td>→<td>UTF-16le TEXT value
5333 ** or a UTF-8 TEXT in bytes
5335 ** <td>→ <td>Size of UTF-16
5353 ** implement [application-defined SQL functions] and [virtual tables].
5363 ** ^The sqlite3_value_text16() interface extracts a UTF-16 string
5364 ** in the native byte-order of the host machine. ^The
5366 ** extract UTF-16 strings as big-endian and little-endian respectively.
5407 ** ^The sqlite3_value_frombind(X) interface returns non-zero if the
5422 ** fail if an out-of-memory error occurs during a format conversion.
5423 ** Only the following subset of interfaces are subject to out-of-memory
5436 ** If an out-of-memory error occurs, then the return value from these
5438 ** Valid SQL NULL returns can be distinguished from out-of-memory errors
5464 ** an [application-defined SQL function] argument V. The subtype
5483 ** then sqlite3_value_free(V) is a harmless no-op.
5544 ** the application-defined function is running.
5564 ** These functions may be used by (non-aggregate) SQL functions to
5568 ** of where this might be useful is in a regular-expression matching
5577 ** value to the application-defined function. ^N is zero for the left-most
5582 ** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th
5583 ** argument of the application-defined function. ^Subsequent
5607 ** function parameters that are compile-time constants, including literal
5610 ** The value of the N parameter to these interfaces should be non-negative.
5637 #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
5653 ** an application-defined function to be the BLOB whose content is pointed
5658 ** interfaces set the result of the application-defined function to be
5662 ** an application-defined function to be a floating point value specified
5670 ** message string from sqlite3_result_error() as UTF-8. ^SQLite
5671 ** interprets the string from sqlite3_result_error16() as UTF-16 using
5672 ** the same [byte-order determination rules] as [sqlite3_bind_text16()].
5677 ** sqlite3_result_error16() is non-negative then SQLite takes that many
5695 ** of the application-defined function to be the 32-bit signed integer
5698 ** of the application-defined function to be the 64-bit signed integer
5702 ** of the application-defined function to be NULL.
5706 ** set the return value of the application-defined function to be
5707 ** a text string which is represented as UTF-8, UTF-16 native byte order,
5708 ** UTF-16 little endian, or UTF-16 big endian, respectively.
5710 ** application-defined function to be a text string in an encoding
5719 ** is non-negative, then as many bytes (not characters) of the text
5720 ** pointed to by the 2nd parameter are taken as the application-defined
5721 ** function result. If the 3rd parameter is non-negative, then it
5728 ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
5744 ** byte-order mark (BOM, U+FEFF) then the BOM is removed from the
5746 ** byte-order specified by the BOM. ^The byte-order specified by
5747 ** the BOM at the beginning of the text overrides the byte-order
5750 ** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the
5761 ** the application-defined function to be a copy of the
5772 ** also associates the host-language pointer P or type T with that
5774 ** [application-defined SQL function] using [sqlite3_value_pointer()].
5782 ** than the one containing the application-defined function that received
5814 ** the result from the [application-defined SQL function] with
5816 ** of the subtype T are preserved in current versions of SQLite;
5830 ** ^The name of the collation is a UTF-8 string
5832 ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
5895 ** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should
5896 ** check the return code and dispose of the application data pointer
5938 ** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
5939 ** the names are passed as UTF-16 in machine native byte order.
5940 ** ^A call to either function replaces the existing collation-needed callback.
5999 ** created by SQLite when using a built-in [sqlite3_vfs | VFS]
6041 ** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
6042 ** TemporaryFolder->Path->Data();
6045 ** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
6058 ** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
6097 ** a non-NULL value will be copied into memory obtained from [sqlite3_malloc]
6102 ** the current directory on the sub-platforms of Win32 where that concept is
6106 ** UTF-8 or UTF-16, respectively.
6125 ** CAPI3REF: Test For Auto-Commit Mode
6129 ** ^The sqlite3_get_autocommit() interface returns non-zero or
6133 ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
6135 ** If certain kinds of errors occur on a statement within a multi-statement
6168 ** connection D, or if database N is a temporary or in-memory database, then
6173 ** is [DETACH]-ed or until the database connection closes.
6194 ** CAPI3REF: Determine if a database is read-only
6198 ** of connection D is read-only, 0 if it is read/write, or -1 if N is not
6217 ** a valid schema, then -1 is returned.
6283 ** ^If the callback on a commit hook function returns non-zero,
6305 ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
6307 ** hook returning non-zero, just as it would be with any other rollback.
6385 ** In prior versions of SQLite,
6406 ** shared cache mode should be enabled per-database connection via
6410 ** 32-bit integer is atomic.
6412 ** See Also: [SQLite Shared-Cache Mode]
6420 ** of heap memory by deallocating non-essential memory allocations
6422 ** pages to improve performance is an example of non-essential memory.
6425 ** ^The sqlite3_release_memory() routine is a no-op returning zero
6439 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
6474 ** sqlite3_soft_heap_limit64(-1) or sqlite3_hard_heap_limit(-1).
6498 ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
6499 ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
6532 ** interface returns SQLITE_OK and fills in the non-NULL pointers in
6536 ** ^If the column-name parameter to sqlite3_table_column_metadata() is a
6603 int *pAutoinc /* OUTPUT: True if column is auto-increment */
6615 ** with various operating-system specific extensions added.
6624 ** X is consists of the lower-case equivalent of all ASCII alphabetic
6663 ** [extension loading] while evaluating user-entered SQL, the following API
6671 ** ^This interface enables or disables both the C-API
6674 ** to enable or disable only the C-API.)^
6714 ** on the list of automatic extensions is a harmless no-op. ^No entry point
6743 ** The interface to the virtual-table mechanism is currently considered
6747 ** When the virtual-table mechanism stabilizes, we will declare the
6808 /* The methods above are in versions 1 and 2 of the sqlite_module object.
6821 ** inputs to xBestIndex and are read-only. xBestIndex inserts its
6833 ** expr on the right-hand side can be evaluated (and thus the constraint
6848 ** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62),
6854 ** non-zero.
6858 ** the right-hand side of the corresponding aConstraint[] is evaluated
6859 ** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit
6888 ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
6919 int iColumn; /* Column constrained. -1 for ROWID */
6922 int iTermOffset; /* Used internally - xBestIndex should ignore */
7106 ** But global versions of those functions
7120 ** The interface to the virtual-table mechanism defined above (back up
7125 ** When the virtual-table mechanism stabilizes, we will declare the
7162 ** ^If the flags parameter is non-zero, then the BLOB is opened for read
7164 ** read-only access.
7200 ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
7216 ** and the built-in [zeroblob] SQL function may be used to create a
7217 ** zero-filled blob to read or write using the incremental-blob interface.
7247 ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
7269 ** ^If the blob handle being closed was opened for read-write access, and if
7270 ** the database is in auto-commit mode and there are no other open read-write
7278 ** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function
7305 ** caller-supplied buffer. N bytes of data are copied into buffer Z
7334 ** caller-supplied buffer. N bytes of data are copied from the buffer Z
7383 ** ^Names are zero-terminated UTF-8 strings.
7414 ** is selected automatically at compile-time. The following
7425 ** a single-threaded application. The SQLITE_MUTEX_PTHREADS and
7430 ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
7467 ** cases where it really needs one. If a faster non-recursive mutex
7474 ** used by the current version of SQLite. Future versions of SQLite
7514 ** behave as no-ops.
7527 ** An instance of this structure defines the low-level routines
7577 ** xMutexInit() must be no-ops.
7617 ** The implementation is not required to provide versions of these
7619 ** versions of these routines, it should at least provide stubs that always
7623 ** the routine should return 1. This seems counter-intuitive since
7627 ** call to sqlite3_mutex_held() to fail, so a non-zero return is
7643 ** next. Applications that override the built-in mutex logic must be
7659 #define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */
7674 ** ^If the [threading mode] is Single-thread or Multi-thread then this
7680 ** CAPI3REF: Low-Level Control Of Database Files
7790 ** by enclosing in double-quotes) so as not to confuse the parser.
7795 ** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and
7798 ** zero-terminated. The sqlite3_keyword_name(N,Z,L) routine returns
7804 ** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero
7816 ** <li> Put all identifier names inside double-quotes. This is the official
7827 ** compile-time options. For example, "VACUUM" is not a keyword if
7828 ** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option. Also,
7839 ** An instance of the sqlite3_str object contains a dynamically-sized
7863 ** valid [sqlite3_str] object, though in the event of an out-of-memory
7903 ** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
7908 ** onto the end of the [sqlite3_str] object X. N must be non-negative.
7909 ** S must contain at least N non-zero bytes of content. To append a
7910 ** zero-terminated string in its entirety, use the [sqlite3_str_appendall()]
7914 ** zero-terminated string S onto the end of [sqlite3_str] object X.
7917 ** single-byte character C onto the end of [sqlite3_str] object X.
7943 ** [SQLITE_NOMEM] following any out-of-memory error, or
7950 ** zero-termination byte.
7985 ** SQLITE_OK on success and a non-zero [error code] on failure.
7988 ** be represented by a 32-bit integer, then the values returned by
8006 ** These integer constants designate various run-time status parameters
8014 ** and internal memory usage by the SQLite library. Auxiliary page-cache
8099 ** non-zero [error code] on failure.
8113 ** might be discontinued. Applications should check the return code from
8115 ** The [sqlite3_db_status()] interface will return a non-zero error code
8125 ** satisfied using lookaside memory. Only the high-water value is meaningful;
8133 ** Only the high-water value is meaningful;
8141 ** Only the high-water value is meaningful;
8164 ** with the connection - main, temp, and any [ATTACH]-ed databases.)^
8204 ** to disk all at once. When pages spill mid-transaction, that introduces
8275 ** A non-zero value in this counter may indicate an opportunity to
8281 ** A non-zero value in this counter may indicate an opportunity to
8368 ** The built-in page cache is recommended for most uses.
8383 ** built-in default page cache is used instead of the application defined
8415 ** false if it is used for an in-memory database. The cache implementation
8426 ** suggested maximum cache-size (number of pages stored by) the cache
8472 ** as its second argument. If the third parameter, discard, is non-zero,
8506 ** is not obligated to free any memory, but well-behaved implementations should
8565 ** for copying in-memory databases to or from persistent files.
8571 ** ^The source database is read-locked only while it is being read;
8605 ** there is already a read or read-write transaction open on the
8637 ** <li> the destination database was opened read-only, or
8638 ** <li> the destination database is using write-ahead-log journaling
8640 ** <li> the destination database is an in-memory database and the
8644 ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
8645 ** the [sqlite3_busy_handler | busy-handler function]
8647 ** busy-handler returns non-zero before the lock is available, then
8668 ** sqlite3_backup_step(), the source database may be modified mid-way
8685 ** active write-transaction on the destination database is rolled back.
8692 ** ^If an out-of-memory condition or IO error occurred during any prior
8726 ** sqlite3_backup_finish(). SQLite does not currently check to see
8761 ** ^When running in shared-cache mode, a database operation may fail with
8762 ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
8763 ** individual tables within the shared-cache cannot be obtained. See
8764 ** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
8768 ** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
8772 ** ^Shared-cache locks are released when a database connection concludes
8776 ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
8786 ** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
8792 ** ^If the blocked connection is attempting to obtain a write-lock on a
8793 ** shared-cache table, and more than one other connection currently holds
8794 ** a read-lock on the same table, then SQLite arbitrarily selects one of
8797 ** ^(There may be at most one unlock-notify callback registered by a
8799 ** blocked connection already has a registered unlock-notify callback,
8802 ** unlock-notify callback is canceled. ^The blocked connections
8803 ** unlock-notify callback may also be canceled by closing the blocked
8806 ** The unlock-notify callback is not reentrant. If an application invokes
8807 ** any sqlite3_xxx API functions from within an unlock-notify callback, a
8815 ** When an unlock-notify callback is registered, the application provides a
8819 ** an unlock-notify callback is a pointer to an array of void* pointers,
8823 ** more than one blocked connection that has registered for an unlock-notify
8833 ** Assuming that after registering for an unlock-notify callback a
8844 ** unlock-notify callback is registered. The system is said to be in
8845 ** a deadlocked state if connection A has registered for an unlock-notify
8847 ** B has itself registered for an unlock-notify callback when connection
8850 ** registered for an unlock-notify callback on the conclusion of connection
8862 ** sqlite3_unlock_notify() results in the unlock-notify callback being
8863 ** invoked immediately. If the application then re-attempts the "DROP TABLE"
8866 ** One way around this problem is to check the extended error code returned
8883 ** and extensions to compare the contents of two buffers containing UTF-8
8884 ** strings in a case-independent fashion, using the same definition of "case
8900 ** Note that this routine returns zero on a match and non-zero if the strings
8917 ** insensitive - equivalent upper and lower case ASCII characters match
8923 ** Note that this routine returns zero on a match and non-zero if the strings
8947 ** a fixed-length buffer on the stack. If the log message is longer than
8954 ** CAPI3REF: Write-Ahead Log Commit Hook
8961 ** the associated write-lock on the database released)^, so the implementation
8967 ** ^The third parameter is the name of the database that was written to -
8968 ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
8969 ** is the number of pages currently in the write-ahead log file,
8980 ** A single database handle may have at most a single write-ahead log callback
8982 ** previously registered write-ahead log callback. ^Note that the
8994 ** CAPI3REF: Configure an auto-checkpoint
9001 ** more frames in the [write-ahead log] file. ^Passing zero or
9016 ** ^Every new [database connection] defaults to having the auto-checkpoint
9032 ** [write-ahead log] for database X on [database connection] D to be
9033 ** transferred into the database file and for the write-ahead log to
9059 ** in the log were checkpointed. ^The [busy-handler callback]
9066 ** [sqlite3_busy_handler|busy-handler callback]) until there is no
9075 ** [busy-handler callback])
9088 ** the log file or to -1 if the checkpoint could not run because
9092 ** was called) or to -1 if the checkpoint could not run due to an error or
9100 ** busy-handler configured, it will not be invoked in this case.
9104 ** obtained immediately, and a busy-handler is configured, it is invoked and
9105 ** the writer lock retried until either the busy-handler returns 0 or the lock
9106 ** is successfully obtained. ^The busy-handler is also invoked while waiting for
9107 ** database readers as described above. ^If the busy-handler returns 0 before
9110 ** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
9126 ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
9202 ** If X is non-zero, then the virtual table implementation guarantees
9267 ** [xUpdate] method understands as a "no-change" value.
9332 ** set to the total number of times that the X-th loop has run.</dd>
9336 ** to the total number of rows examined by all iterations of the X-th loop.</dd>
9341 ** iteration of the X-th loop. If the query planner's estimates was accurate,
9348 ** to a zero-terminated UTF-8 string containing the name of the index or table
9349 ** used for the X-th loop.
9353 ** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
9354 ** description for the X-th loop.
9358 ** "select-id" for the X-th loop. The select-id identifies which query or
9359 ** subquery the loop is part of. The main query has a select-id of zero.
9360 ** The select-id is the same value as is output in the first column
9382 ** compile-time option.
9390 ** Loops are numbered starting from zero. ^If idx is out of range - less than
9392 ** the statement - a non-zero value is returned and the variable that pOut
9397 ** as if the loop did not exist - it returns non-zero and leave the variable
9410 ** CAPI3REF: Zero Scan-Status Counters
9415 ** This API is only available if the library is built with pre-processor
9421 ** CAPI3REF: Flush caches to disk mid-transaction
9424 ** ^If a write-transaction is open on [database connection] D when the
9426 ** pages in the pager-cache that are not currently in use are written out
9430 ** interface flushes caches for all schemas - "main", "temp", and
9435 ** immediately and there is a busy-handler callback configured, it is invoked
9443 ** example an IO error or out-of-memory condition), then processing is
9454 ** CAPI3REF: The pre-update hook.
9458 ** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option.
9530 ** operation; or 1 for inserts, updates, or deletes invoked by top-level
9531 ** triggers; or 2 for changes resulting from triggers called by top-level
9557 ** CAPI3REF: Low-level system error code
9562 ** The return value is OS-dependent. For example, on unix systems, after
9602 ** If there is not already a read-transaction open on schema S when
9634 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
9668 ** is returned. If another error code - for example SQLITE_PROTOCOL or an
9669 ** SQLITE_IOERR error code - is returned, then the final state of the
9683 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
9700 ** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
9767 ** For an ordinary on-disk database file, the serialization is just a
9768 ** copy of the disk file. For an in-memory database or a "TEMP" database,
9805 ** Zero or more of the following constants can be OR-ed together for
9809 ** a pointer to contiguous in-memory database that it is currently using,
9811 ** a contiguous in-memory database, then this option causes
9813 ** using a contiguous in-memory database if it has been initialized by a
9823 ** reopen S as an in-memory database based on the serialization contained
9827 ** permitted to add content to the in-memory database as long as the total
9875 ** should be treated as read-only.
9879 #define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */
9919 /* The double-precision datatype used by RTree depends on the
9920 ** SQLITE_RTREE_INT_ONLY compile-time option.
9930 ** R-Tree geometry query as follows:
9955 ** Register a 2nd-generation geometry callback named zScore that can be
9956 ** used as part of an R-Tree geometry query as follows:
9984 sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */
10062 ** is not possible for an application to register a pre-update hook on a
10065 ** which a pre-update hook is already defined. The results of attempting
10101 ** disabled - it does not. A newly created session object is enabled.
10108 ** no-op, and may be used to query the current state of the session.
10185 ** rows a zero-length blob (SQL value X'') is stored in the changeset or
10191 ** zero-length blob back to a NULL value when updating the sqlite_stat1
10195 ** conflict-handler callback) then the X'' value is returned. The application
10198 ** Legacy (older than 3.22.0) versions of the sessions module cannot capture
10199 ** changes made to the sqlite_stat1 table. Legacy versions of the
10243 ** database row along with the updated values for each updated non-primary-key
10252 ** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL,
10254 ** with non-NULL PRIMARY KEY values is updated so that one or more of its
10267 ** are sorted in the same order in which they were attached (or auto-attached)
10281 ** recorded once - the first time a row with said primary key is inserted,
10288 ** The session object therefore accumulates two types of records - those
10306 ** found and one or more of the non-primary key fields have been
10323 ** This may appear to have some counter-intuitive effects if a single row
10345 ** does not have a primary key, this function is a no-op (but does not return
10365 ** used to update the table in database zFrom (call this the "from-table")
10367 ** object (call this the "to-table"). Specifically:
10370 ** <li> For each row (primary key) that exists in the to-table but not in
10371 ** the from-table, an INSERT record is added to the session object.
10373 ** <li> For each row (primary key) that exists in the to-table but not in
10374 ** the from-table, a DELETE record is added to the session object.
10377 ** different non-PK values in each, an UPDATE record is added to the
10416 ** A patchset blob may be used with up to date versions of all
10419 ** attempting to use a patchset blob with old versions of the
10422 ** Because the non-primary key "old.*" fields are omitted, no
10441 ** Return non-zero if no changes to attached tables have been recorded by
10449 ** are restored. However, if this function returns non-zero, then it is
10536 ** a conflict-handler callback by [sqlite3changeset_apply()], SQLITE_MISUSE
10560 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
10573 ** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
10576 ** or until the conflict-handler function returns.
10623 unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */
10632 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
10663 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
10697 ** conflict-handler callback by [sqlite3changeset_apply()] with either
10708 ** "conflicting row" associated with the current conflict-handler callback
10746 ** function with an iterator passed to a conflict-handler by
10754 ** returned. This is to allow the following pattern (pseudo-code):
10880 ** versions sqlite3changegroup_add_strm() and sqlite3changegroup_output_strm().
10907 ** <table border=1 style="margin-left:8ex;margin-right:8ex">
10908 ** <tr><th style="white-space:pre">Existing Change </th>
10909 ** <th style="white-space:pre">New Change </th>
10954 ** returned. Or, if an out-of-memory condition occurs during processing, this
11012 ** Otherwise, if the return value is non-zero or the xFilter argument to
11048 ** SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If the conflict-handler
11052 ** returned by each invocation of the conflict-handler function. Refer to
11061 ** stored in all non-primary key columns also match the values stored in
11065 ** the non-primary key fields contains a value different from the original
11066 ** row value stored in the changeset, the conflict-handler function is
11069 ** only the values of those non-primary key fields are compared against
11070 ** the current database contents - any trailing database table columns
11074 ** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND]
11079 ** conflict-handler function is invoked with [SQLITE_CHANGESET_CONSTRAINT]
11098 ** This includes the case where the INSERT operation is re-attempted because
11106 ** stored in all modified non-primary key columns also match the values
11110 ** the modified non-primary key fields contains a value different from an
11111 ** original row value stored in the changeset, the conflict-handler function
11113 ** UPDATE changes only contain values for non-primary key fields that are
11115 ** avoid the SQLITE_CHANGESET_DATA conflict-handler callback.
11118 ** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND]
11122 ** SQLITE_CONSTRAINT, the conflict-handler function is invoked with
11140 ** If the output parameters (ppRebase) and (pnRebase) are non-NULL and
11217 ** Values that may be passed as the second argument to a conflict-handler.
11224 ** (non primary-key) fields modified by the update do not contain the
11261 ** a UNIQUE, CHECK or NOT NULL constraint), the conflict handler is
11385 ** combined on a per-field basis, not per-row. This means that in the
11466 ** CAPI3REF: Streaming Versions of API functions.
11469 ** corresponding non-streaming API functions:
11471 ** <table border=1 style="margin-left:8ex;margin-right:8ex">
11472 ** <tr><th>Streaming function<th>Non-streaming equivalent</th>
11482 ** Non-streaming functions that accept changesets (or patchsets) as input
11487 ** low-memory environment is required to handle very large changesets, the
11751 ** non-negative but less than the number of columns in the table, return
11766 ** non-negative but less than the number of columns in the table, set
11780 ** containing the text in utf-8 encoding, (*pn) is set to the size in bytes
11878 ** If the bClear argument is non-zero, then the auxiliary data is cleared
11900 ** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
11902 ** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
11908 ** modify this structure directly - it should only be used as shown above
11916 ** through an empty set (all calls to xPhraseFirst() set iCol to -1).
11930 ** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
11932 ** pApi->xPhraseNextColumn(pFts, &iter, &iCol)
11941 ** xPhraseFirstColumn() set iCol to -1).
12010 ** The second and third arguments are an array of nul-terminated strings
12028 ** by argument pText. pText may or may not be nul-terminated. The first
12036 ** <ul><li> <b>FTS5_TOKENIZE_DOCUMENT</b> - A document is being inserted into
12041 ** <li> <b>FTS5_TOKENIZE_QUERY</b> - A MATCH query is being executed
12045 ** <li> <b>(FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX)</b> - Same as
12050 ** <li> <b>FTS5_TOKENIZE_AUX</b> - The tokenizer is being invoked to
12083 ** built-in tokenizers, the FTS5 query 'first + place' will match instances
12117 ** still appears to contain just two phrases - "(first OR 1st)"
12128 ** when tokenizing query text (it should not - to do so would be
12175 ** provide synonyms for prefixes). However, a non-prefix query like '1st'