simcop2387/DBD-SQLite-SQLcipher
1
0
Fork 0
mirror of https://github.com/DBD-SQLite/DBD-SQLite synced 2025-06-08 06:38:12 -04:00
Code Issues Releases Wiki Activity

updated bundled SQLite to 3.6.18

Browse source
This commit is contained in:
Darren Duncan 2009-09-11 17:53:58 +00:00
parent 631ef3df94
commit ef2d70e94c
3 changed files with 4723 additions and 2854 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Changes
View file

@ -1,6 +1,7 @@
Changes for Perl extension DBD-SQLite Changes for Perl extension DBD-SQLite
1.26_04 to be released 1.26_04 to be released
- Updated to SQLite 3.6.18 (DUNCAND)
- Resolved #48393: previous effort was not enough; BegunWork - Resolved #48393: previous effort was not enough; BegunWork
should also be handled properly (ISHIGAKI) should also be handled properly (ISHIGAKI)
- Replaced last DBILOGFP with DBIc_LOGPIO(imp_xxh) (ISHIGAKI) - Replaced last DBILOGFP with DBIc_LOGPIO(imp_xxh) (ISHIGAKI)

7026
sqlite3.c
View file

File diff suppressed because it is too large Load diff

320
sqlite3.h
View file

@ -18,8 +18,8 @@
** Some of the definitions that are in this file are marked as ** Some of the definitions that are in this file are marked as
** "experimental". Experimental interfaces are normally new ** "experimental". Experimental interfaces are normally new
** features recently added to SQLite. We do not anticipate changes ** features recently added to SQLite. We do not anticipate changes
** to experimental interfaces but reserve to make minor changes if ** to experimental interfaces but reserve the right to make minor changes
** experience from use "in the wild" suggest such changes are prudent. ** if experience from use "in the wild" suggest such changes are prudent.
** **
** The official C-language API documentation for SQLite is derived ** The official C-language API documentation for SQLite is derived
** from comments in this file. This file is the authoritative source ** from comments in this file. This file is the authoritative source
@ -29,8 +29,6 @@
** The makefile makes some minor changes to this file (such as inserting ** The makefile makes some minor changes to this file (such as inserting
** the version number) and changes its name to "sqlite3.h" as ** the version number) and changes its name to "sqlite3.h" as
** part of the build process. ** part of the build process.
**
** @(#) $Id: sqlite.h.in,v 1.462 2009/08/06 17:40:46 drh Exp $
*/ */
#ifndef _SQLITE3_H_ #ifndef _SQLITE3_H_
#define _SQLITE3_H_ #define _SQLITE3_H_
@ -59,7 +57,7 @@ extern "C" {
/* /*
** These no-op macros are used in front of interfaces to mark those ** These no-op macros are used in front of interfaces to mark those
** interfaces as either deprecated or experimental. New applications ** interfaces as either deprecated or experimental. New applications
** should not use deprecated intrfaces - they are support for backwards ** should not use deprecated interfaces - they are support for backwards
** compatibility only. Application writers should be aware that ** compatibility only. Application writers should be aware that
** experimental interfaces are subject to change in point releases. ** experimental interfaces are subject to change in point releases.
** **
@ -89,51 +87,81 @@ extern "C" {
** the sqlite3.h file specify the version of SQLite with which ** the sqlite3.h file specify the version of SQLite with which
** that header file is associated. ** that header file is associated.
** **
** The "version" of SQLite is a string of the form "X.Y.Z". ** The "version" of SQLite is a string of the form "W.X.Y" or "W.X.Y.Z".
** The phrase "alpha" or "beta" might be appended after the Z. ** The W value is major version number and is always 3 in SQLite3.
** The X value is major version number always 3 in SQLite3. ** The W value only changes when backwards compatibility is
** The X value only changes when backwards compatibility is
** broken and we intend to never break backwards compatibility. ** broken and we intend to never break backwards compatibility.
** The Y value is the minor version number and only changes when ** The X value is the minor version number and only changes when
** there are major feature enhancements that are forwards compatible ** there are major feature enhancements that are forwards compatible
** but not backwards compatible. ** but not backwards compatible.
** The Z value is the release number and is incremented with ** The Y value is the release number and is incremented with
** each release but resets back to 0 whenever Y is incremented. ** each release but resets back to 0 whenever X is incremented.
** The Z value only appears on branch releases.
** **
** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. ** The SQLITE_VERSION_NUMBER is an integer that is computed as
** follows:
**
** <blockquote><pre>
** SQLITE_VERSION_NUMBER = W*1000000 + X*1000 + Y
** </pre></blockquote>
**
** Since version 3.6.18, SQLite source code has been stored in the
** <a href="http://www.fossil-scm.org/">fossil configuration management
** system</a>. The SQLITE_SOURCE_ID
** macro is a string which identifies a particular check-in of SQLite
** within its configuration management system. The string contains the
** date and time of the check-in (UTC) and an SHA1 hash of the entire
** source tree.
**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
** **
** Requirements: [H10011] [H10014] ** Requirements: [H10011] [H10014]
*/ */
#define SQLITE_VERSION "3.6.17" #define SQLITE_VERSION "3.6.18"
#define SQLITE_VERSION_NUMBER 3006017 #define SQLITE_VERSION_NUMBER 3006018
#define SQLITE_SOURCE_ID "2009-09-11 14:05:07 b084828a771ec40be85f07c590ca99de4f6c24ee"
/* /*
** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100> ** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
** KEYWORDS: sqlite3_version ** KEYWORDS: sqlite3_version
** **
** These features provide the same information as the [SQLITE_VERSION] ** These interfaces provide the same information as the [SQLITE_VERSION],
** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] #defines in the header,
** with the library instead of the header file. Cautious programmers might ** but are associated with the library instead of the header file. Cautious
** include a check in their application to verify that ** programmers might include assert() statements in their application to
** sqlite3_libversion_number() always returns the value ** verify that values returned by these interfaces match the macros in
** [SQLITE_VERSION_NUMBER]. ** the header, and thus insure that the application is
** compiled with matching library and header files.
**
** <blockquote><pre>
** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
** assert( strcmp(sqlite3_libversion,SQLITE_VERSION)==0 );
** </pre></blockquote>
** **
** The sqlite3_libversion() function returns the same information as is ** The sqlite3_libversion() function returns the same information as is
** in the sqlite3_version[] string constant. The function is provided ** in the sqlite3_version[] string constant. The function is provided
** for use in DLLs since DLL users usually do not have direct access to string ** for use in DLLs since DLL users usually do not have direct access to string
** constants within the DLL. ** constants within the DLL. Similarly, the sqlite3_sourceid() function
** returns the same information as is in the [SQLITE_SOURCE_ID] #define of
** the header file.
**
** See also: [sqlite_version()] and [sqlite_source_id()].
** **
** Requirements: [H10021] [H10022] [H10023] ** Requirements: [H10021] [H10022] [H10023]
*/ */
SQLITE_API SQLITE_EXTERN const char sqlite3_version[]; SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
SQLITE_API const char *sqlite3_libversion(void); SQLITE_API const char *sqlite3_libversion(void);
SQLITE_API const char *sqlite3_sourceid(void);
SQLITE_API int sqlite3_libversion_number(void); SQLITE_API int sqlite3_libversion_number(void);
/* /*
** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100> ** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100>
** **
** SQLite can be compiled with or without mutexes. When ** SQLite can be compiled with or without mutexes. When
** the [SQLITE_THREADSAFE] C preprocessor macro 1 or 2, mutexes ** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
** are enabled and SQLite is threadsafe. When the ** are enabled and SQLite is threadsafe. When the
** [SQLITE_THREADSAFE] macro is 0, ** [SQLITE_THREADSAFE] macro is 0,
** the mutexes are omitted. Without the mutexes, it is not safe ** the mutexes are omitted. Without the mutexes, it is not safe
@ -144,7 +172,7 @@ SQLITE_API int sqlite3_libversion_number(void);
** the mutexes. But for maximum safety, mutexes should be enabled. ** the mutexes. But for maximum safety, mutexes should be enabled.
** The default behavior is for mutexes to be enabled. ** The default behavior is for mutexes to be enabled.
** **
** This interface can be used by a program to make sure that the ** This interface can be used by an application to make sure that the
** version of SQLite that it is linking against was compiled with ** version of SQLite that it is linking against was compiled with
** the desired setting of the [SQLITE_THREADSAFE] macro. ** the desired setting of the [SQLITE_THREADSAFE] macro.
** **
@ -411,6 +439,8 @@ SQLITE_API int sqlite3_exec(
#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ #define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
/* /*
** CAPI3REF: Device Characteristics {H10240} <H11120> ** CAPI3REF: Device Characteristics {H10240} <H11120>
@ -478,8 +508,9 @@ SQLITE_API int sqlite3_exec(
/* /*
** CAPI3REF: OS Interface Open File Handle {H11110} <S20110> ** CAPI3REF: OS Interface Open File Handle {H11110} <S20110>
** **
** An [sqlite3_file] object represents an open file in the OS ** An [sqlite3_file] object represents an open file in the
** interface layer. Individual OS interface implementations will ** [sqlite3_vfs | OS interface layer]. Individual OS interface
** implementations will
** want to subclass this object by appending additional fields ** want to subclass this object by appending additional fields
** for their own use. The pMethods entry is a pointer to an ** for their own use. The pMethods entry is a pointer to an
** [sqlite3_io_methods] object that defines methods for performing ** [sqlite3_io_methods] object that defines methods for performing
@ -855,8 +886,9 @@ struct sqlite3_vfs {
** interface is called automatically by sqlite3_initialize() and ** interface is called automatically by sqlite3_initialize() and
** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate ** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate
** implementations for sqlite3_os_init() and sqlite3_os_end() ** implementations for sqlite3_os_init() and sqlite3_os_end()
** are built into SQLite when it is compiled for unix, windows, or os/2. ** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
** When built for other platforms (using the [SQLITE_OS_OTHER=1] compile-time ** When [custom builds | built for other platforms]
** (using the [SQLITE_OS_OTHER=1] compile-time
** option) the application must supply a suitable implementation for ** option) the application must supply a suitable implementation for
** sqlite3_os_init() and sqlite3_os_end(). An application-supplied ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied
** implementation of sqlite3_os_init() or sqlite3_os_end() ** implementation of sqlite3_os_init() or sqlite3_os_end()
@ -937,13 +969,15 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
** This object is used in only one place in the SQLite interface. ** This object is used in only one place in the SQLite interface.
** A pointer to an instance of this object is the argument to ** A pointer to an instance of this object is the argument to
** [sqlite3_config()] when the configuration option is ** [sqlite3_config()] when the configuration option is
** [SQLITE_CONFIG_MALLOC]. By creating an instance of this object ** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
** and passing it to [sqlite3_config()] during configuration, an ** By creating an instance of this object
** application can specify an alternative memory allocation subsystem ** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
** for SQLite to use for all of its dynamic memory needs. ** during configuration, an application can specify an alternative
** memory allocation subsystem for SQLite to use for all of its
** dynamic memory needs.
** **
** Note that SQLite comes with a built-in memory allocator that is ** Note that SQLite comes with several [built-in memory allocators]
** perfectly adequate for the overwhelming majority of applications ** that are perfectly adequate for the overwhelming majority of applications
** and that this object is only useful to a tiny minority of applications ** and that this object is only useful to a tiny minority of applications
** with specialized memory allocation requirements. This object is ** with specialized memory allocation requirements. This object is
** also used during testing of SQLite in order to specify an alternative ** also used during testing of SQLite in order to specify an alternative
@ -951,8 +985,16 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
** order to verify that SQLite recovers gracefully from such ** order to verify that SQLite recovers gracefully from such
** conditions. ** conditions.
** **
** The xMalloc, xFree, and xRealloc methods must work like the ** The xMalloc and xFree methods must work like the
** malloc(), free(), and realloc() functions from the standard library. ** malloc() and free() functions from the standard C library.
** The xRealloc method must work like realloc() from the standard C library
** with the exception that if the second argument to xRealloc is zero,
** xRealloc must be a no-op - it must not perform any allocation or
** deallocation. SQLite guaranteeds that the second argument to
** xRealloc is always a value returned by a prior call to xRoundup.
** And so in cases where xRoundup always returns a positive number,
** xRealloc can perform exactly as the standard library realloc() and
** still be in compliance with this specification.
** **
** xSize should return the allocated size of a memory allocation ** xSize should return the allocated size of a memory allocation
** previously obtained from xMalloc or xRealloc. The allocated size ** previously obtained from xMalloc or xRealloc. The allocated size
@ -962,6 +1004,9 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
** a memory allocation given a particular requested size. Most memory ** a memory allocation given a particular requested size. Most memory
** allocators round up memory allocations at least to the next multiple ** allocators round up memory allocations at least to the next multiple
** of 8. Some allocators round up to a larger multiple or to a power of 2. ** of 8. Some allocators round up to a larger multiple or to a power of 2.
** Every memory allocation request coming in through [sqlite3_malloc()]
** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0,
** that causes the corresponding memory allocation to fail.
** **
** The xInit method initializes the memory allocator. (For example, ** The xInit method initializes the memory allocator. (For example,
** it might allocate any require mutexes or initialize internal data ** it might allocate any require mutexes or initialize internal data
@ -969,6 +1014,20 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
** [sqlite3_shutdown()] and should deallocate any resources acquired ** [sqlite3_shutdown()] and should deallocate any resources acquired
** by xInit. The pAppData pointer is used as the only parameter to ** by xInit. The pAppData pointer is used as the only parameter to
** xInit and xShutdown. ** xInit and xShutdown.
**
** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
** the xInit method, so the xInit method need not be threadsafe. The
** xShutdown method is only called from [sqlite3_shutdown()] so it does
** not need to be threadsafe either. For all other methods, SQLite
** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
** it is by default) and so the methods are automatically serialized.
** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
** methods must be threadsafe or else make their own arrangements for
** serialization.
**
** SQLite will never invoke xInit() more than once without an intervening
** call to xShutdown().
*/ */
typedef struct sqlite3_mem_methods sqlite3_mem_methods; typedef struct sqlite3_mem_methods sqlite3_mem_methods;
struct sqlite3_mem_methods { struct sqlite3_mem_methods {
@ -1122,9 +1181,12 @@ struct sqlite3_mem_methods {
** **
** <dt>SQLITE_CONFIG_LOOKASIDE</dt> ** <dt>SQLITE_CONFIG_LOOKASIDE</dt>
** <dd>This option takes two arguments that determine the default ** <dd>This option takes two arguments that determine the default
** memory allcation lookaside optimization. The first argument is the ** memory allocation lookaside optimization. The first argument is the
** size of each lookaside buffer slot and the second is the number of ** size of each lookaside buffer slot and the second is the number of
** slots allocated to each database connection.</dd> ** slots allocated to each database connection. This option sets the
** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
** verb to [sqlite3_db_config()] can be used to change the lookaside
** configuration on individual connections.</dd>
** **
** <dt>SQLITE_CONFIG_PCACHE</dt> ** <dt>SQLITE_CONFIG_PCACHE</dt>
** <dd>This option takes a single argument which is a pointer to ** <dd>This option takes a single argument which is a pointer to
@ -1174,12 +1236,15 @@ struct sqlite3_mem_methods {
** <dd>This option takes three additional arguments that determine the ** <dd>This option takes three additional arguments that determine the
** [lookaside memory allocator] configuration for the [database connection]. ** [lookaside memory allocator] configuration for the [database connection].
** The first argument (the third parameter to [sqlite3_db_config()] is a ** The first argument (the third parameter to [sqlite3_db_config()] is a
** pointer to an 8-byte aligned memory buffer to use for lookaside memory. ** pointer to an memory buffer to use for lookaside memory.
** The first argument may be NULL in which case SQLite will allocate the ** The first argument may be NULL in which case SQLite will allocate the
** lookaside buffer itself using [sqlite3_malloc()]. The second argument is the ** lookaside buffer itself using [sqlite3_malloc()]. The second argument is the
** size of each lookaside buffer slot and the third argument is the number of ** size of each lookaside buffer slot and the third argument is the number of
** slots. The size of the buffer in the first argument must be greater than ** slots. The size of the buffer in the first argument must be greater than
** or equal to the product of the second and third arguments.</dd> ** or equal to the product of the second and third arguments. The buffer
** must be aligned to an 8-byte boundary. If the second argument is not
** a multiple of 8, it is internally rounded down to the next smaller
** multiple of 8. See also: [SQLITE_CONFIG_LOOKASIDE]</dd>
** **
** </dl> ** </dl>
*/ */
@ -1583,7 +1648,7 @@ SQLITE_API void sqlite3_free_table(char **result);
/* /*
** CAPI3REF: Formatted String Printing Functions {H17400} <S70000><S20000> ** CAPI3REF: Formatted String Printing Functions {H17400} <S70000><S20000>
** **
** These routines are workalikes of the "printf()" family of functions ** These routines are work-alikes of the "printf()" family of functions
** from the standard C library. ** from the standard C library.
** **
** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their ** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
@ -1870,7 +1935,7 @@ SQLITE_API void sqlite3_randomness(int N, void *P);
** database connections for the meaning of "modify" in this paragraph. ** database connections for the meaning of "modify" in this paragraph.
** **
** When [sqlite3_prepare_v2()] is used to prepare a statement, the ** When [sqlite3_prepare_v2()] is used to prepare a statement, the
** statement might be reprepared during [sqlite3_step()] due to a ** statement might be re-prepared during [sqlite3_step()] due to a
** schema change. Hence, the application should ensure that the ** schema change. Hence, the application should ensure that the
** correct authorizer callback remains in place during the [sqlite3_step()]. ** correct authorizer callback remains in place during the [sqlite3_step()].
** **
@ -2037,7 +2102,8 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
** except that it accepts two additional parameters for additional control ** except that it accepts two additional parameters for additional control
** over the new database connection. The flags parameter can take one of ** over the new database connection. The flags parameter can take one of
** the following three values, optionally combined with the ** the following three values, optionally combined with the
** [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags: ** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
** and/or [SQLITE_OPEN_PRIVATECACHE] flags:
** **
** <dl> ** <dl>
** <dt>[SQLITE_OPEN_READONLY]</dt> ** <dt>[SQLITE_OPEN_READONLY]</dt>
@ -2057,7 +2123,8 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
** **
** If the 3rd parameter to sqlite3_open_v2() is not one of the ** If the 3rd parameter to sqlite3_open_v2() is not one of the
** combinations shown above or one of the combinations shown above combined ** combinations shown above or one of the combinations shown above combined
** with the [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags, ** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX],
** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags,
** then the behavior is undefined. ** then the behavior is undefined.
** **
** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
@ -2066,6 +2133,11 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
** in the serialized [threading mode] unless single-thread was ** in the serialized [threading mode] unless single-thread was
** previously selected at compile-time or start-time. ** previously selected at compile-time or start-time.
** The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
** eligible to use [shared cache mode], regardless of whether or not shared
** cache is enabled using [sqlite3_enable_shared_cache()]. The
** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
** participate in [shared cache mode] even if it is enabled.
** **
** If the filename is ":memory:", then a private, temporary in-memory database ** If the filename is ":memory:", then a private, temporary in-memory database
** is created for the connection. This in-memory database will vanish when ** is created for the connection. This in-memory database will vanish when
@ -2259,6 +2331,9 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
** <dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt> ** <dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
** <dd>The maximum number of variables in an SQL statement that can ** <dd>The maximum number of variables in an SQL statement that can
** be bound.</dd> ** be bound.</dd>
**
** <dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
** <dd>The maximum depth of recursion for triggers.</dd>
** </dl> ** </dl>
*/ */
#define SQLITE_LIMIT_LENGTH 0 #define SQLITE_LIMIT_LENGTH 0
@ -2271,6 +2346,7 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
#define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_ATTACHED 7
#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
#define SQLITE_LIMIT_VARIABLE_NUMBER 9 #define SQLITE_LIMIT_VARIABLE_NUMBER 9
#define SQLITE_LIMIT_TRIGGER_DEPTH 10
/* /*
** CAPI3REF: Compiling An SQL Statement {H13010} <S10000> ** CAPI3REF: Compiling An SQL Statement {H13010} <S10000>
@ -2447,7 +2523,8 @@ typedef struct sqlite3_context sqlite3_context;
** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
** **
** In the SQL strings input to [sqlite3_prepare_v2()] and its variants, ** In the SQL strings input to [sqlite3_prepare_v2()] and its variants,
** literals may be replaced by a [parameter] in one of these forms: ** literals may be replaced by a [parameter] that matches one of following
** templates:
** **
** <ul> ** <ul>
** <li> ? ** <li> ?
@ -2457,8 +2534,8 @@ typedef struct sqlite3_context sqlite3_context;
** <li> $VVV ** <li> $VVV
** </ul> ** </ul>
** **
** In the parameter forms shown above NNN is an integer literal, ** In the templates above, NNN represents an integer literal,
** and VVV is an alpha-numeric parameter name. The values of these ** and VVV represents an alphanumeric identifer. The values of these
** parameters (also called "host parameter names" or "SQL parameters") ** parameters (also called "host parameter names" or "SQL parameters")
** can be set using the sqlite3_bind_*() routines defined here. ** can be set using the sqlite3_bind_*() routines defined here.
** **
@ -3110,7 +3187,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
** [SQLITE_UTF8 | text encoding] this SQL function prefers for ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
** its parameters. Any SQL function implementation should be able to work ** its parameters. Any SQL function implementation should be able to work
** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be ** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be
** more efficient with one encoding than another. It is allowed to ** more efficient with one encoding than another. An application may
** invoke sqlite3_create_function() or sqlite3_create_function16() multiple ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
** times with the same function but with different values of eTextRep. ** times with the same function but with different values of eTextRep.
** When multiple implementations of the same function are available, SQLite ** When multiple implementations of the same function are available, SQLite
@ -3132,7 +3209,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
** It is permitted to register multiple implementations of the same ** It is permitted to register multiple implementations of the same
** functions with the same name but with either differing numbers of ** functions with the same name but with either differing numbers of
** arguments or differing preferred text encodings. SQLite will use ** arguments or differing preferred text encodings. SQLite will use
** the implementation most closely matches the way in which the ** the implementation that most closely matches the way in which the
** SQL function is used. A function implementation with a non-negative ** SQL function is used. A function implementation with a non-negative
** nArg parameter is a better match than a function implementation with ** nArg parameter is a better match than a function implementation with
** a negative nArg. A function where the preferred text encoding ** a negative nArg. A function where the preferred text encoding
@ -3480,10 +3557,11 @@ typedef void (*sqlite3_destructor_type)(void*);
** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
** function as the destructor on the text or BLOB result when it has ** function as the destructor on the text or BLOB result when it has
** finished using that result. ** finished using that result.
** If the 4th parameter to the sqlite3_result_text* interfaces or ** If the 4th parameter to the sqlite3_result_text* interfaces or to
** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
** assumes that the text or BLOB result is in constant space and does not ** assumes that the text or BLOB result is in constant space and does not
** copy the it or call a destructor when it has finished using that result. ** copy the content of the parameter nor call a destructor on the content
** when it has finished using that result.
** If the 4th parameter to the sqlite3_result_text* interfaces ** If the 4th parameter to the sqlite3_result_text* interfaces
** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
** then SQLite makes a copy of the result into space obtained from ** then SQLite makes a copy of the result into space obtained from
@ -4462,7 +4540,7 @@ typedef struct sqlite3_blob sqlite3_blob;
** **
** Use the [sqlite3_blob_bytes()] interface to determine the size of ** Use the [sqlite3_blob_bytes()] interface to determine the size of
** the opened blob. The size of a blob may not be changed by this ** the opened blob. The size of a blob may not be changed by this
** underface. Use the [UPDATE] SQL command to change the size of a ** interface. Use the [UPDATE] SQL command to change the size of a
** blob. ** blob.
** **
** The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces ** The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
@ -4702,7 +4780,7 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
** might return such a mutex in response to SQLITE_MUTEX_FAST. ** might return such a mutex in response to SQLITE_MUTEX_FAST.
** **
** {H17017} The other allowed parameters to sqlite3_mutex_alloc() each return ** {H17017} The other allowed parameters to sqlite3_mutex_alloc() each return
** a pointer to a static preexisting mutex. {END} Four static mutexes are ** a pointer to a static preexisting mutex. {END} Six static mutexes are
** used by the current version of SQLite. Future versions of SQLite ** used by the current version of SQLite. Future versions of SQLite
** may add additional static mutexes. Static mutexes are for internal ** may add additional static mutexes. Static mutexes are for internal
** use by SQLite only. Applications that use SQLite mutexes should ** use by SQLite only. Applications that use SQLite mutexes should
@ -4808,6 +4886,21 @@ SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
** of passing a NULL pointer instead of a valid mutex handle are undefined ** of passing a NULL pointer instead of a valid mutex handle are undefined
** (i.e. it is acceptable to provide an implementation that segfaults if ** (i.e. it is acceptable to provide an implementation that segfaults if
** it is passed a NULL pointer). ** it is passed a NULL pointer).
**
** The xMutexInit() method must be threadsafe. It must be harmless to
** invoke xMutexInit() mutiple times within the same process and without
** intervening calls to xMutexEnd(). Second and subsequent calls to
** xMutexInit() must be no-ops.
**
** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
** and its associates). Similarly, xMutexAlloc() must not use SQLite memory
** allocation for a static mutex. However xMutexAlloc() may use SQLite
** memory allocation for a fast or recursive mutex.
**
** SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
** called, but only if the prior call to xMutexInit returned SQLITE_OK.
** If xMutexInit fails in any way, it is expected to clean up after itself
** prior to returning.
*/ */
typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
struct sqlite3_mutex_methods { struct sqlite3_mutex_methods {
@ -4973,7 +5066,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
** This routine returns SQLITE_OK on success and a non-zero ** This routine returns SQLITE_OK on success and a non-zero
** [error code] on failure. ** [error code] on failure.
** **
** This routine is threadsafe but is not atomic. This routine can ** This routine is threadsafe but is not atomic. This routine can be
** called while other threads are running the same or different SQLite ** called while other threads are running the same or different SQLite
** interfaces. However the values returned in *pCurrent and ** interfaces. However the values returned in *pCurrent and
** *pHighwater reflect the status of SQLite at different points in time ** *pHighwater reflect the status of SQLite at different points in time
@ -5096,7 +5189,14 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur
** CAPI3REF: Status Parameters for database connections {H17520} <H17500> ** CAPI3REF: Status Parameters for database connections {H17520} <H17500>
** EXPERIMENTAL ** EXPERIMENTAL
** **
** Status verbs for [sqlite3_db_status()]. ** These constants are the available integer "verbs" that can be passed as
** the second argument to the [sqlite3_db_status()] interface.
**
** New verbs may be added in future releases of SQLite. Existing verbs
** might be discontinued. Applications should check the return code from
** [sqlite3_db_status()] to make sure that the call worked.
** The [sqlite3_db_status()] interface will return a non-zero error code
** if a discontinued or unsupported verb is invoked.
** **
** <dl> ** <dl>
** <dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt> ** <dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
@ -5174,95 +5274,109 @@ typedef struct sqlite3_pcache sqlite3_pcache;
/* /*
** CAPI3REF: Application Defined Page Cache. ** CAPI3REF: Application Defined Page Cache.
** KEYWORDS: {page cache}
** EXPERIMENTAL ** EXPERIMENTAL
** **
** The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can ** The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can
** register an alternative page cache implementation by passing in an ** register an alternative page cache implementation by passing in an
** instance of the sqlite3_pcache_methods structure. The majority of the ** instance of the sqlite3_pcache_methods structure. The majority of the
** heap memory used by sqlite is used by the page cache to cache data read ** heap memory used by SQLite is used by the page cache to cache data read
** from, or ready to be written to, the database file. By implementing a ** from, or ready to be written to, the database file. By implementing a
** custom page cache using this API, an application can control more ** custom page cache using this API, an application can control more
** precisely the amount of memory consumed by sqlite, the way in which ** precisely the amount of memory consumed by SQLite, the way in which
** said memory is allocated and released, and the policies used to ** that memory is allocated and released, and the policies used to
** determine exactly which parts of a database file are cached and for ** determine exactly which parts of a database file are cached and for
** how long. ** how long.
** **
** The contents of the structure are copied to an internal buffer by sqlite ** The contents of the sqlite3_pcache_methods structure are copied to an
** within the call to [sqlite3_config]. ** internal buffer by SQLite within the call to [sqlite3_config]. Hence
** the application may discard the parameter after the call to
** [sqlite3_config()] returns.
** **
** The xInit() method is called once for each call to [sqlite3_initialize()] ** The xInit() method is called once for each call to [sqlite3_initialize()]
** (usually only once during the lifetime of the process). It is passed ** (usually only once during the lifetime of the process). It is passed
** a copy of the sqlite3_pcache_methods.pArg value. It can be used to set ** a copy of the sqlite3_pcache_methods.pArg value. It can be used to set
** up global structures and mutexes required by the custom page cache ** up global structures and mutexes required by the custom page cache
** implementation. The xShutdown() method is called from within ** implementation.
** [sqlite3_shutdown()], if the application invokes this API. It can be used
** to clean up any outstanding resources before process shutdown, if required.
** **
** The xCreate() method is used to construct a new cache instance. The ** The xShutdown() method is called from within [sqlite3_shutdown()],
** if the application invokes this API. It can be used to clean up
** any outstanding resources before process shutdown, if required.
**
** SQLite holds a [SQLITE_MUTEX_RECURSIVE] mutex when it invokes
** the xInit method, so the xInit method need not be threadsafe. The
** xShutdown method is only called from [sqlite3_shutdown()] so it does
** not need to be threadsafe either. All other methods must be threadsafe
** in multithreaded applications.
**
** SQLite will never invoke xInit() more than once without an intervening
** call to xShutdown().
**
** The xCreate() method is used to construct a new cache instance. SQLite
** will typically create one cache instance for each open database file,
** though this is not guaranteed. The
** first parameter, szPage, is the size in bytes of the pages that must ** first parameter, szPage, is the size in bytes of the pages that must
** be allocated by the cache. szPage will not be a power of two. The ** be allocated by the cache. szPage will not be a power of two. szPage
** second argument, bPurgeable, is true if the cache being created will ** will the page size of the database file that is to be cached plus an
** be used to cache database pages read from a file stored on disk, or ** increment (here called "R") of about 100 or 200. SQLite will use the
** extra R bytes on each page to store metadata about the underlying
** database page on disk. The value of R depends
** on the SQLite version, the target platform, and how SQLite was compiled.
** R is constant for a particular build of SQLite. The second argument to
** xCreate(), bPurgeable, is true if the cache being created will
** be used to cache database pages of a file stored on disk, or
** false if it is used for an in-memory database. The cache implementation ** false if it is used for an in-memory database. The cache implementation
** does not have to do anything special based on the value of bPurgeable, ** does not have to do anything special based with the value of bPurgeable;
** it is purely advisory. ** it is purely advisory. On a cache where bPurgeable is false, SQLite will
** never invoke xUnpin() except to deliberately delete a page.
** In other words, a cache created with bPurgeable set to false will
** never contain any unpinned pages.
** **
** The xCachesize() method may be called at any time by SQLite to set the ** The xCachesize() method may be called at any time by SQLite to set the
** suggested maximum cache-size (number of pages stored by) the cache ** suggested maximum cache-size (number of pages stored by) the cache
** instance passed as the first argument. This is the value configured using ** instance passed as the first argument. This is the value configured using
** the SQLite "[PRAGMA cache_size]" command. As with the bPurgeable parameter, ** the SQLite "[PRAGMA cache_size]" command. As with the bPurgeable parameter,
** the implementation is not required to do anything special with this ** the implementation is not required to do anything with this
** value, it is advisory only. ** value; it is advisory only.
** **
** The xPagecount() method should return the number of pages currently ** The xPagecount() method should return the number of pages currently
** stored in the cache supplied as an argument. ** stored in the cache.
** **
** The xFetch() method is used to fetch a page and return a pointer to it. ** The xFetch() method is used to fetch a page and return a pointer to it.
** A 'page', in this context, is a buffer of szPage bytes aligned at an ** A 'page', in this context, is a buffer of szPage bytes aligned at an
** 8-byte boundary. The page to be fetched is determined by the key. The ** 8-byte boundary. The page to be fetched is determined by the key. The
** mimimum key value is 1. After it has been retrieved using xFetch, the page ** mimimum key value is 1. After it has been retrieved using xFetch, the page
** is considered to be pinned. ** is considered to be "pinned".
** **
** If the requested page is already in the page cache, then a pointer to ** If the requested page is already in the page cache, then the page cache
** the cached buffer should be returned with its contents intact. If the ** implementation must return a pointer to the page buffer with its content
** page is not already in the cache, then the expected behaviour of the ** intact. If the requested page is not already in the cache, then the
** cache is determined by the value of the createFlag parameter passed ** behavior of the cache implementation is determined by the value of the
** to xFetch, according to the following table: ** createFlag parameter passed to xFetch, according to the following table:
** **
** <table border=1 width=85% align=center> ** <table border=1 width=85% align=center>
** <tr><th>createFlag<th>Expected Behaviour ** <tr><th> createFlag <th> Behaviour when page is not already in cache
** <tr><td>0<td>NULL should be returned. No new cache entry is created. ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
** <tr><td>1<td>If createFlag is set to 1, this indicates that ** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
** SQLite is holding pinned pages that can be unpinned ** Otherwise return NULL.
** by writing their contents to the database file (a ** <tr><td> 2 <td> Make every effort to allocate a new page. Only return
** relatively expensive operation). In this situation the ** NULL if allocating a new page is effectively impossible.
** cache implementation has two choices: it can return NULL,
** in which case SQLite will attempt to unpin one or more
** pages before re-requesting the same page, or it can
** allocate a new page and return a pointer to it. If a new
** page is allocated, then the first sizeof(void*) bytes of
** it (at least) must be zeroed before it is returned.
** <tr><td>2<td>If createFlag is set to 2, then SQLite is not holding any
** pinned pages associated with the specific cache passed
** as the first argument to xFetch() that can be unpinned. The
** cache implementation should attempt to allocate a new
** cache entry and return a pointer to it. Again, the first
** sizeof(void*) bytes of the page should be zeroed before
** it is returned. If the xFetch() method returns NULL when
** createFlag==2, SQLite assumes that a memory allocation
** failed and returns SQLITE_NOMEM to the user.
** </table> ** </table>
** **
** SQLite will normally invoke xFetch() with a createFlag of 0 or 1. If
** a call to xFetch() with createFlag==1 returns NULL, then SQLite will
** attempt to unpin one or more cache pages by spilling the content of
** pinned pages to disk and synching the operating system disk cache. After
** attempting to unpin pages, the xFetch() method will be invoked again with
** a createFlag of 2.
**
** xUnpin() is called by SQLite with a pointer to a currently pinned page ** xUnpin() is called by SQLite with a pointer to a currently pinned page
** as its second argument. If the third parameter, discard, is non-zero, ** as its second argument. If the third parameter, discard, is non-zero,
** then the page should be evicted from the cache. In this case SQLite ** then the page should be evicted from the cache. In this case SQLite
** assumes that the next time the page is retrieved from the cache using ** assumes that the next time the page is retrieved from the cache using
** the xFetch() method, it will be zeroed. If the discard parameter is ** the xFetch() method, it will be zeroed. If the discard parameter is
** zero, then the page is considered to be unpinned. The cache implementation ** zero, then the page is considered to be unpinned. The cache implementation
** may choose to reclaim (free or recycle) unpinned pages at any time. ** may choose to evict unpinned pages at any time.
** SQLite assumes that next time the page is retrieved from the cache
** it will either be zeroed, or contain the same data that it did when it
** was unpinned.
** **
** The cache is not required to perform any reference counting. A single ** The cache is not required to perform any reference counting. A single
** call to xUnpin() unpins the page regardless of the number of prior calls ** call to xUnpin() unpins the page regardless of the number of prior calls