direct-sqlite 2.3.24 → 2.3.26
raw patch · 6 files changed
+477/−131 lines, 6 filesdep ~basedep ~semigroupsPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base, semigroups
API changes (from Hackage documentation)
Files
- Database/SQLite3/Direct.hs +20/−17
- cbits/sqlite3.c too large to diff
- cbits/sqlite3.h +428/−109
- cbits/sqlite3ext.h +19/−0
- changelog +6/−1
- direct-sqlite.cabal +4/−4
Database/SQLite3/Direct.hs view
@@ -1,6 +1,7 @@-{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE ScopedTypeVariables #-} -- | -- This API is a slightly lower-level version of "Database.SQLite3". Namely: --@@ -134,24 +135,26 @@ ArgIndex, ) where -import Database.SQLite3.Bindings--import qualified Data.ByteString as BS-import qualified Data.ByteString.Unsafe as BSU-import qualified Data.ByteString.Internal as BSI-import Data.Semigroup (Semigroup)+import Control.Exception as E+import Control.Monad (join, unless)+import Data.ByteString (ByteString)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Internal as BSI+import qualified Data.ByteString.Unsafe as BSU+import Data.IORef+import Data.String (IsString(..)) import qualified Data.Text as T import qualified Data.Text.Encoding as T-import Control.Exception as E-import Control.Monad (join, unless)-import Data.ByteString (ByteString)-import Data.IORef-import Data.String (IsString(..))-import Data.Text.Encoding.Error (lenientDecode)-import Foreign-import Foreign.C+import Data.Text.Encoding.Error (lenientDecode)+import Database.SQLite3.Bindings+import Foreign+import Foreign.C import qualified System.IO.Unsafe as IOU +#if !MIN_VERSION_base(4,11,0)+import Data.Semigroup (Semigroup)+#endif+ newtype Database = Database (Ptr CDatabase) deriving (Eq, Show) @@ -725,7 +728,7 @@ maybeArgCount :: Maybe ArgCount -> CArgCount maybeArgCount (Just n) = toFFI n-maybeArgCount Nothing = -1+maybeArgCount Nothing = -1 funcArgCount :: FuncArgs -> ArgCount funcArgCount (FuncArgs nArgs _) = fromIntegral nArgs
cbits/sqlite3.c view
file too large to diff
cbits/sqlite3.h view
@@ -123,9 +123,9 @@ ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */-#define SQLITE_VERSION "3.24.0"-#define SQLITE_VERSION_NUMBER 3024000-#define SQLITE_SOURCE_ID "2018-06-04 19:24:41 c7ee0833225bfd8c5ec2f9bf62b97c4e04d03bd9566366d5221ac8fb199a87ca"+#define SQLITE_VERSION "3.28.0"+#define SQLITE_VERSION_NUMBER 3028000+#define SQLITE_SOURCE_ID "2019-04-16 19:49:53 884b4b7e502b4e991677b53971277adfaf0a04a284f8e483e2553d0f83156b50" /* ** CAPI3REF: Run-Time Library Version Numbers@@ -189,6 +189,9 @@ #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS SQLITE_API int sqlite3_compileoption_used(const char *zOptName); SQLITE_API const char *sqlite3_compileoption_get(int N);+#else+# define sqlite3_compileoption_used(X) 0+# define sqlite3_compileoption_get(X) ((void*)0) #endif /*@@ -472,6 +475,7 @@ */ #define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8)) #define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8))+#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8)) #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))@@ -511,6 +515,7 @@ #define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) #define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) #define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8))+#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) #define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8)) #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))@@ -821,6 +826,15 @@ ** file space based on this hint in order to help writes to the database ** file run faster. **+** <li>[[SQLITE_FCNTL_SIZE_LIMIT]]+** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that+** implements [sqlite3_deserialize()] to set an upper bound on the size+** of the in-memory database. The argument is a pointer to a [sqlite3_int64].+** If the integer pointed to is negative, then it is filled in with the+** current limit. Otherwise the limit is set to the larger of the value+** of the integer pointed to and the current database size. The integer+** pointed to is set to the new limit.+** ** <li>[[SQLITE_FCNTL_CHUNK_SIZE]] ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS ** extends and truncates the database file in chunks of a size specified@@ -886,7 +900,8 @@ ** <li>[[SQLITE_FCNTL_PERSIST_WAL]] ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the ** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary-** write ahead log and shared memory files used for transaction control+** write ahead log ([WAL file]) and shared memory+** files used for transaction control ** are automatically deleted when the latest connection to the database ** closes. Setting persistent WAL mode causes those files to persist after ** close. Persisting the files is useful when other processes that do not@@ -1072,6 +1087,26 @@ ** a file lock using the xLock or xShmLock methods of the VFS to wait ** for up to M milliseconds before failing, where M is the single ** unsigned integer parameter.+**+** <li>[[SQLITE_FCNTL_DATA_VERSION]]+** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to+** a database file. The argument is a pointer to a 32-bit unsigned integer.+** The "data version" for the pager is written into the pointer. The+** "data version" changes whenever any change occurs to the corresponding+** database file, either through SQL statements on the same database+** connection or through transactions committed by separate database+** connections possibly in other processes. The [sqlite3_total_changes()]+** interface can be used to find if any database on the connection has changed,+** but that interface responds to changes on TEMP as well as MAIN and does+** not provide a mechanism to detect changes to MAIN only. Also, the+** [sqlite3_total_changes()] interface responds to internal changes only and+** omits changes made by other database connections. The+** [PRAGMA data_version] command provide a mechanism to detect changes to+** a single attached database that occur due to other database connections,+** but omits changes implemented by the database connection on which it is+** called. This file control is the only mechanism to detect changes that+** happen either internally or externally and that are associated with+** a particular attached database. ** </ul> */ #define SQLITE_FCNTL_LOCKSTATE 1@@ -1107,6 +1142,8 @@ #define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32 #define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33 #define SQLITE_FCNTL_LOCK_TIMEOUT 34+#define SQLITE_FCNTL_DATA_VERSION 35+#define SQLITE_FCNTL_SIZE_LIMIT 36 /* deprecated names */ #define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE@@ -1948,6 +1985,17 @@ ** negative value for this option restores the default behaviour. ** This option is only available if SQLite is compiled with the ** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.+**+** [[SQLITE_CONFIG_MEMDB_MAXSIZE]]+** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE+** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter+** [sqlite3_int64] parameter which is the default maximum size for an in-memory+** database created using [sqlite3_deserialize()]. This default maximum+** size can be adjusted up or down for individual databases using the+** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this+** configuration setting is never used, then the default maximum is determined+** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that+** compile-time option is not set, then the default maximum is 1073741824. ** </dl> */ #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */@@ -1978,6 +2026,7 @@ #define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */ #define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */ #define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */+#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */ /* ** CAPI3REF: Database Connection Configuration Options@@ -1993,6 +2042,7 @@ ** is invoked. ** ** <dl>+** [[SQLITE_DBCONFIG_LOOKASIDE]] ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt> ** <dd> ^This option takes three additional arguments that determine the ** [lookaside memory allocator] configuration for the [database connection].@@ -2015,6 +2065,7 @@ ** memory is in use leaves the configuration unchanged and returns ** [SQLITE_BUSY].)^</dd> **+** [[SQLITE_DBCONFIG_ENABLE_FKEY]] ** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt> ** <dd> ^This option is used to enable or disable the enforcement of ** [foreign key constraints]. There should be two additional arguments.@@ -2025,6 +2076,7 @@ ** following this call. The second parameter may be a NULL pointer, in ** which case the FK enforcement setting is not reported back. </dd> **+** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] ** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt> ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers]. ** There should be two additional arguments.@@ -2035,9 +2087,10 @@ ** following this call. The second parameter may be a NULL pointer, in ** which case the trigger setting is not reported back. </dd> **+** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>-** <dd> ^This option is used to enable or disable the two-argument-** version of the [fts3_tokenizer()] function which is part of the+** <dd> ^This option is used to enable or disable the+** [fts3_tokenizer()] function which is part of the ** [FTS3] full-text search engine extension. ** There should be two additional arguments. ** The first argument is an integer which is 0 to disable fts3_tokenizer() or@@ -2048,6 +2101,7 @@ ** following this call. The second parameter may be a NULL pointer, in ** which case the new setting is not reported back. </dd> **+** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] ** <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt> ** <dd> ^This option is used to enable or disable the [sqlite3_load_extension()] ** interface independently of the [load_extension()] SQL function.@@ -2065,7 +2119,7 @@ ** be a NULL pointer, in which case the new setting is not reported back. ** </dd> **-** <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>+** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt> ** <dd> ^This option is used to change the name of the "main" database ** schema. ^The sole argument is a pointer to a constant UTF8 string ** which will become the new schema name in place of "main". ^SQLite@@ -2074,6 +2128,7 @@ ** until after the database connection closes. ** </dd> **+** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]] ** <dt>SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE</dt> ** <dd> Usually, when a database in wal mode is closed or detached from a ** database handle, SQLite checks if this will mean that there are now no @@ -2087,7 +2142,7 @@ ** have been disabled - 0 if they are not disabled, 1 if they are. ** </dd> **-** <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt>+** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt> ** <dd>^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates ** the [query planner stability guarantee] (QPSG). When the QPSG is active, ** a single SQL query statement will always use the same algorithm regardless@@ -2103,7 +2158,7 @@ ** following this call. ** </dd> **-** <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt>+** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt> ** <dd> By default, the output of EXPLAIN QUERY PLAN commands does not ** include output for any operations performed by trigger programs. This ** option is used to set or clear (the default) a flag that governs this@@ -2115,12 +2170,18 @@ ** it is not disabled, 1 if it is. ** </dd> **-** <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt>+** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt> ** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run ** [VACUUM] in order to reset a database back to an empty database ** with no schema and no content. The following process works even for ** a badly corrupted database file: ** <ol>+** <li> If the database connection is newly opened, make sure it has read the+** database schema by preparing then discarding some query against the+** database, or calling sqlite3_table_column_metadata(), ignoring any+** errors. This step is only necessary if the application desires to keep+** the database in WAL mode after the reset if it was in WAL mode before+** the reset. ** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); ** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); ** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);@@ -2128,7 +2189,30 @@ ** Because resetting a database is destructive and irreversible, the ** process requires the use of this obscure API and multiple steps to help ** ensure that it does not happen by accident.+**+** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>+** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the+** "defensive" flag for a database connection. When the defensive+** flag is enabled, language features that allow ordinary SQL to +** deliberately corrupt the database file are disabled. The disabled+** features include but are not limited to the following:+** <ul>+** <li> The [PRAGMA writable_schema=ON] statement.+** <li> Writes to the [sqlite_dbpage] virtual table.+** <li> Direct writes to [shadow tables].+** </ul> ** </dd>+**+** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>+** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the+** "writable_schema" flag. This has the same effect and is logically equivalent+** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF].+** The first argument to this setting is an integer which is 0 to disable +** the writable_schema, positive to enable writable_schema, or negative to+** leave the setting unchanged. The second parameter is a pointer to an+** integer into which is written 0 or 1 to indicate whether the writable_schema+** is enabled or disabled following this call.+** </dd> ** </dl> */ #define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */@@ -2141,7 +2225,9 @@ #define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */ #define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */ #define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */-#define SQLITE_DBCONFIG_MAX 1009 /* Largest DBCONFIG */+#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */+#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */+#define SQLITE_DBCONFIG_MAX 1011 /* Largest DBCONFIG */ /* ** CAPI3REF: Enable Or Disable Extended Result Codes@@ -2269,12 +2355,17 @@ ** program, the value returned reflects the number of rows modified by the ** previous INSERT, UPDATE or DELETE statement within the same trigger. **-** See also the [sqlite3_total_changes()] interface, the-** [count_changes pragma], and the [changes() SQL function].-** ** If a separate thread makes changes on the same database connection ** while [sqlite3_changes()] is running then the value returned ** is unpredictable and not meaningful.+**+** See also:+** <ul>+** <li> the [sqlite3_total_changes()] interface+** <li> the [count_changes pragma]+** <li> the [changes() SQL function]+** <li> the [data_version pragma]+** </ul> */ SQLITE_API int sqlite3_changes(sqlite3*); @@ -2292,13 +2383,26 @@ ** count, but those made as part of REPLACE constraint resolution are ** not. ^Changes to a view that are intercepted by INSTEAD OF triggers ** are not counted.-** -** See also the [sqlite3_changes()] interface, the-** [count_changes pragma], and the [total_changes() SQL function]. **+** The [sqlite3_total_changes(D)] interface only reports the number+** of rows that changed due to SQL statement run against database+** connection D. Any changes by other database connections are ignored.+** To detect changes against a database file from other database+** connections use the [PRAGMA data_version] command or the+** [SQLITE_FCNTL_DATA_VERSION] [file control].+** ** If a separate thread makes changes on the same database connection ** while [sqlite3_total_changes()] is running then the value ** returned is unpredictable and not meaningful.+**+** See also:+** <ul>+** <li> the [sqlite3_changes()] interface+** <li> the [count_changes pragma]+** <li> the [changes() SQL function]+** <li> the [data_version pragma]+** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control]+** </ul> */ SQLITE_API int sqlite3_total_changes(sqlite3*); @@ -2924,9 +3028,9 @@ ** time is in units of nanoseconds, however the current implementation ** is only capable of millisecond resolution so the six least significant ** digits in the time are meaningless. Future versions of SQLite-** might provide greater resolution on the profiler callback. The-** sqlite3_profile() function is considered experimental and is-** subject to change in future versions of SQLite.+** might provide greater resolution on the profiler callback. Invoking+** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the+** profile callback. */ SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);@@ -3340,6 +3444,8 @@ ** is not a database file pathname pointer that SQLite passed into the xOpen ** VFS method, then the behavior of this routine is undefined and probably ** undesirable.+**+** See the [URI filename] documentation for additional information. */ SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam); SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);@@ -3354,13 +3460,24 @@ ** [database connection] D failed, then the sqlite3_errcode(D) interface ** returns the numeric [result code] or [extended result code] for that ** API call.-** If the most recent API call was successful,-** then the return value from sqlite3_errcode() is undefined. ** ^The sqlite3_extended_errcode() ** interface is the same except that it always returns the ** [extended result code] even when extended result codes are ** disabled. **+** The values returned by sqlite3_errcode() and/or+** sqlite3_extended_errcode() might change with each API call.+** Except, there are some interfaces that are guaranteed to never+** change the value of the error code. The error-code preserving+** interfaces are:+**+** <ul>+** <li> sqlite3_errcode()+** <li> sqlite3_extended_errcode()+** <li> sqlite3_errmsg()+** <li> sqlite3_errmsg16()+** </ul>+** ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language ** text that describes the error, as either UTF-8 or UTF-16 respectively. ** ^(Memory to hold the error message string is managed internally.@@ -3550,9 +3667,24 @@ ** on this hint by avoiding the use of [lookaside memory] so as not to ** deplete the limited store of lookaside memory. Future versions of ** SQLite may act on this hint differently.+**+** [[SQLITE_PREPARE_NORMALIZE]] <dt>SQLITE_PREPARE_NORMALIZE</dt>+** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used+** to be required for any prepared statement that wanted to use the+** [sqlite3_normalized_sql()] interface. However, the+** [sqlite3_normalized_sql()] interface is now available to all+** prepared statements, regardless of whether or not they use this+** flag.+**+** [[SQLITE_PREPARE_NO_VTAB]] <dt>SQLITE_PREPARE_NO_VTAB</dt>+** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler+** to return an error (error code SQLITE_ERROR) if the statement uses+** any virtual tables. ** </dl> */ #define SQLITE_PREPARE_PERSISTENT 0x01+#define SQLITE_PREPARE_NORMALIZE 0x02+#define SQLITE_PREPARE_NO_VTAB 0x04 /* ** CAPI3REF: Compiling An SQL Statement@@ -3710,6 +3842,11 @@ ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 ** string containing the SQL text of prepared statement P with ** [bound parameters] expanded.+** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8+** string containing the normalized SQL text of prepared statement P. The+** semantics used to normalize a SQL statement are unspecified and subject+** to change. At a minimum, literal values will be replaced with suitable+** placeholders. ** ** ^(For example, if a prepared statement is created using the SQL ** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345@@ -3725,14 +3862,16 @@ ** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time ** option causes sqlite3_expanded_sql() to always return NULL. **-** ^The string returned by sqlite3_sql(P) is managed by SQLite and is-** automatically freed when the prepared statement is finalized.+** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P)+** are managed by SQLite and are automatically freed when the prepared+** statement is finalized. ** ^The string returned by sqlite3_expanded_sql(P), on the other hand, ** is obtained from [sqlite3_malloc()] and must be free by the application ** by passing it to [sqlite3_free()]. */ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);+SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); /* ** CAPI3REF: Determine If An SQL Statement Writes The Database@@ -3771,6 +3910,18 @@ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); /*+** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement+** METHOD: sqlite3_stmt+**+** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the+** prepared statement S is an EXPLAIN statement, or 2 if the+** statement S is an EXPLAIN QUERY PLAN.+** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is+** an ordinary statement or a NULL pointer.+*/+SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);++/* ** CAPI3REF: Determine If A Prepared Statement Has Been Reset ** METHOD: sqlite3_stmt **@@ -3909,7 +4060,9 @@ ** ^The fifth argument to the BLOB and string binding interfaces ** is a destructor used to dispose of the BLOB or ** string after SQLite has finished with it. ^The destructor is called-** to dispose of the BLOB or string even if the call to bind API fails.+** to dispose of the BLOB or string even if the call to the bind API fails,+** except the destructor is not called if the third parameter is a NULL+** pointer or the fourth parameter is negative. ** ^If the fifth argument is ** the special value [SQLITE_STATIC], then SQLite assumes that the ** information is in static, unmanaged space and does not need to be freed.@@ -4514,11 +4667,25 @@ ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into ** [sqlite3_free()]. **-** ^(If a memory allocation error occurs during the evaluation of any-** of these routines, a default value is returned. The default value-** is either the integer 0, the floating point number 0.0, or a NULL-** pointer. Subsequent calls to [sqlite3_errcode()] will return-** [SQLITE_NOMEM].)^+** As long as the input parameters are correct, these routines will only+** fail if an out-of-memory error occurs during a format conversion.+** Only the following subset of interfaces are subject to out-of-memory+** errors:+**+** <ul>+** <li> sqlite3_column_blob()+** <li> sqlite3_column_text()+** <li> sqlite3_column_text16()+** <li> sqlite3_column_bytes()+** <li> sqlite3_column_bytes16()+** </ul>+**+** If an out-of-memory error occurs, then the return value from these+** routines is the same as if the column had contained an SQL NULL value.+** Valid SQL NULL returns can be distinguished from out-of-memory errors+** by invoking the [sqlite3_errcode()] immediately after the suspect+** return value is obtained and before any+** other SQLite interface is called on the same [database connection]. */ SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);@@ -4595,11 +4762,13 @@ ** ** ^These functions (collectively known as "function creation routines") ** are used to add SQL functions or aggregates or to redefine the behavior-** of existing SQL functions or aggregates. The only differences between-** these routines are the text encoding expected for-** the second parameter (the name of the function being created)-** and the presence or absence of a destructor callback for-** the application data pointer.+** of existing SQL functions or aggregates. The only differences between+** the three "sqlite3_create_function*" routines are the text encoding +** expected for the second parameter (the name of the function being +** created) and the presence or absence of a destructor callback for+** the application data pointer. Function sqlite3_create_window_function()+** is similar, but allows the user to supply the extra callback functions+** needed by [aggregate window functions]. ** ** ^The first parameter is the [database connection] to which the SQL ** function is to be added. ^If an application uses more than one database@@ -4645,7 +4814,8 @@ ** ^(The fifth parameter is an arbitrary pointer. The implementation of the ** function can gain access to this pointer using [sqlite3_user_data()].)^ **-** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are+** ^The sixth, seventh and eighth parameters passed to the three+** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are ** pointers to C-language functions that implement the SQL function or ** aggregate. ^A scalar SQL function requires an implementation of the xFunc ** callback only; NULL pointers must be passed as the xStep and xFinal@@ -4654,16 +4824,25 @@ ** SQL function or aggregate, pass NULL pointers for all three function ** callbacks. **-** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,-** then it is destructor for the application data pointer. -** The destructor is invoked when the function is deleted, either by being-** overloaded or when the database connection closes.)^-** ^The destructor is also invoked if the call to-** sqlite3_create_function_v2() fails.-** ^When the destructor callback of the tenth parameter is invoked, it-** is passed a single argument which is a copy of the application data -** pointer which was the fifth parameter to sqlite3_create_function_v2().+** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue +** and xInverse) passed to sqlite3_create_window_function are pointers to+** C-language callbacks that implement the new function. xStep and xFinal+** must both be non-NULL. xValue and xInverse may either both be NULL, in+** which case a regular aggregate function is created, or must both be +** non-NULL, in which case the new function may be used as either an aggregate+** or aggregate window function. More details regarding the implementation+** of aggregate window functions are +** [user-defined window functions|available here]. **+** ^(If the final parameter to sqlite3_create_function_v2() or+** sqlite3_create_window_function() is not NULL, then it is destructor for+** the application data pointer. The destructor is invoked when the function +** is deleted, either by being overloaded or when the database connection +** closes.)^ ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. ^When the destructor callback is+** invoked, it is passed a single argument which is a copy of the application+** data pointer which was the fifth parameter to sqlite3_create_function_v2().+** ** ^It is permitted to register multiple implementations of the same ** functions with the same name but with either differing numbers of ** arguments or differing preferred text encodings. ^SQLite will use@@ -4715,6 +4894,18 @@ void (*xFinal)(sqlite3_context*), void(*xDestroy)(void*) );+SQLITE_API int sqlite3_create_window_function(+ sqlite3 *db,+ const char *zFunctionName,+ int nArg,+ int eTextRep,+ void *pApp,+ void (*xStep)(sqlite3_context*,int,sqlite3_value**),+ void (*xFinal)(sqlite3_context*),+ void (*xValue)(sqlite3_context*),+ void (*xInverse)(sqlite3_context*,int,sqlite3_value**),+ void(*xDestroy)(void*)+); /* ** CAPI3REF: Text Encodings@@ -4788,6 +4979,8 @@ ** <tr><td><b>sqlite3_value_nochange </b> ** <td>→ <td>True if the column is unchanged in an UPDATE ** against a virtual table.+** <tr><td><b>sqlite3_value_frombind </b>+** <td>→ <td>True if value originated from a [bound parameter] ** </table></blockquote> ** ** <b>Details:</b>@@ -4849,6 +5042,11 @@ ** than within an [xUpdate] method call for an UPDATE statement, then ** the return value is arbitrary and meaningless. **+** ^The sqlite3_value_frombind(X) interface returns non-zero if the+** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()]+** interfaces. ^If X comes from an SQL literal value, or a table column,+** and expression, then sqlite3_value_frombind(X) returns zero.+** ** Please pay particular attention to the fact that the pointer returned ** from [sqlite3_value_blob()], [sqlite3_value_text()], or ** [sqlite3_value_text16()] can be invalidated by a subsequent call to@@ -4857,6 +5055,28 @@ ** ** These routines must be called from the same thread as ** the SQL function that supplied the [sqlite3_value*] parameters.+**+** As long as the input parameter is correct, these routines can only+** fail if an out-of-memory error occurs during a format conversion.+** Only the following subset of interfaces are subject to out-of-memory+** errors:+**+** <ul>+** <li> sqlite3_value_blob()+** <li> sqlite3_value_text()+** <li> sqlite3_value_text16()+** <li> sqlite3_value_text16le()+** <li> sqlite3_value_text16be()+** <li> sqlite3_value_bytes()+** <li> sqlite3_value_bytes16()+** </ul>+**+** If an out-of-memory error occurs, then the return value from these+** routines is the same as if the column had contained an SQL NULL value.+** Valid SQL NULL returns can be distinguished from out-of-memory errors+** by invoking the [sqlite3_errcode()] immediately after the suspect+** return value is obtained and before any+** other SQLite interface is called on the same [database connection]. */ SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); SQLITE_API double sqlite3_value_double(sqlite3_value*);@@ -4872,6 +5092,7 @@ SQLITE_API int sqlite3_value_type(sqlite3_value*); SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); SQLITE_API int sqlite3_value_nochange(sqlite3_value*);+SQLITE_API int sqlite3_value_frombind(sqlite3_value*); /* ** CAPI3REF: Finding The Subtype Of SQL Values@@ -5607,7 +5828,7 @@ ** associated with database N of connection D. ^The main database file ** has the name "main". If there is no attached database N on the database ** connection D, or if database N is a temporary or in-memory database, then-** a NULL pointer is returned.+** this function will return either a NULL pointer or an empty string. ** ** ^The filename returned by this function is the output of the ** xFullPathname method of the [VFS]. ^In other words, the filename@@ -6162,6 +6383,9 @@ int (*xSavepoint)(sqlite3_vtab *pVTab, int); int (*xRelease)(sqlite3_vtab *pVTab, int); int (*xRollbackTo)(sqlite3_vtab *pVTab, int);+ /* The methods above are in versions 1 and 2 of the sqlite_module object.+ ** Those below are for version 3 and greater. */+ int (*xShadowName)(const char*); }; /*@@ -6323,6 +6547,7 @@ #define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70 #define SQLITE_INDEX_CONSTRAINT_ISNULL 71 #define SQLITE_INDEX_CONSTRAINT_IS 72+#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 /* ** CAPI3REF: Register A Virtual Table Implementation@@ -6999,6 +7224,7 @@ /* ** CAPI3REF: Low-Level Control Of Database Files ** METHOD: sqlite3+** KEYWORDS: {file control} ** ** ^The [sqlite3_file_control()] interface makes a direct call to the ** xFileControl method for the [sqlite3_io_methods] object associated@@ -7013,11 +7239,18 @@ ** the xFileControl method. ^The return value of the xFileControl ** method becomes the return value of this routine. **+** A few opcodes for [sqlite3_file_control()] are handled directly+** by the SQLite core and never invoke the +** sqlite3_io_methods.xFileControl method. ** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes ** a pointer to the underlying [sqlite3_file] object to be written into-** the space pointed to by the 4th parameter. ^The [SQLITE_FCNTL_FILE_POINTER]-** case is a short-circuit path which does not actually invoke the-** underlying sqlite3_io_methods.xFileControl method.+** the space pointed to by the 4th parameter. The+** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns+** the [sqlite3_file] object associated with the journal file instead of+** the main database. The [SQLITE_FCNTL_VFS_POINTER] opcode returns+** a pointer to the underlying [sqlite3_vfs] object for the file.+** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter+** from the pager. ** ** ^If the second parameter (zDbName) does not match the name of any ** open database file, then SQLITE_ERROR is returned. ^This error@@ -7075,6 +7308,7 @@ #define SQLITE_TESTCTRL_OPTIMIZATIONS 15 #define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */ #define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */+#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17 #define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 #define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */ #define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19@@ -8487,6 +8721,7 @@ ** can use to customize and optimize their behavior. ** ** <dl>+** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] ** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT ** <dd>Calls of the form ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,@@ -8836,7 +9071,6 @@ /* ** CAPI3REF: Database Snapshot ** KEYWORDS: {snapshot} {sqlite3_snapshot}-** EXPERIMENTAL ** ** An instance of the snapshot object records the state of a [WAL mode] ** database for some specific point in history.@@ -8853,11 +9087,6 @@ ** version of the database file so that it is possible to later open a new read ** transaction that sees that historical version of the database rather than ** the most recent version.-**-** The constructor for this object is [sqlite3_snapshot_get()]. The-** [sqlite3_snapshot_open()] method causes a fresh read transaction to refer-** to an historical snapshot (if possible). The destructor for -** sqlite3_snapshot objects is [sqlite3_snapshot_free()]. */ typedef struct sqlite3_snapshot { unsigned char hidden[48];@@ -8865,7 +9094,7 @@ /* ** CAPI3REF: Record A Database Snapshot-** EXPERIMENTAL+** CONSTRUCTOR: sqlite3_snapshot ** ** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a ** new [sqlite3_snapshot] object that records the current state of@@ -8881,7 +9110,7 @@ ** in this case. ** ** <ul>-** <li> The database handle must be in [autocommit mode].+** <li> The database handle must not be in [autocommit mode]. ** ** <li> Schema S of [database connection] D must be a [WAL mode] database. **@@ -8904,7 +9133,7 @@ ** to avoid a memory leak. ** ** The [sqlite3_snapshot_get()] interface is only available when the-** SQLITE_ENABLE_SNAPSHOT compile-time option is used.+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. */ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get( sqlite3 *db,@@ -8914,24 +9143,35 @@ /* ** CAPI3REF: Start a read transaction on an historical snapshot-** EXPERIMENTAL+** METHOD: sqlite3_snapshot **-** ^The [sqlite3_snapshot_open(D,S,P)] interface starts a-** read transaction for schema S of-** [database connection] D such that the read transaction-** refers to historical [snapshot] P, rather than the most-** recent change to the database.-** ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK on success-** or an appropriate [error code] if it fails.+** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read +** transaction or upgrades an existing one for schema S of +** [database connection] D such that the read transaction refers to +** historical [snapshot] P, rather than the most recent change to the +** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK +** on success or an appropriate [error code] if it fails. **-** ^In order to succeed, a call to [sqlite3_snapshot_open(D,S,P)] must be-** the first operation following the [BEGIN] that takes the schema S-** out of [autocommit mode].-** ^In other words, schema S must not currently be in-** a transaction for [sqlite3_snapshot_open(D,S,P)] to work, but the-** database connection D must be out of [autocommit mode].-** ^A [snapshot] will fail to open if it has been overwritten by a-** [checkpoint].+** ^In order to succeed, the database connection must not be in +** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there+** is already a read transaction open on schema S, then the database handle+** must have no active statements (SELECT statements that have been passed+** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()). +** SQLITE_ERROR is returned if either of these conditions is violated, or+** if schema S does not exist, or if the snapshot object is invalid.+**+** ^A call to sqlite3_snapshot_open() will fail to open if the specified+** snapshot has been overwritten by a [checkpoint]. In this case +** SQLITE_ERROR_SNAPSHOT is returned.+**+** If there is already a read transaction open when this function is +** invoked, then the same read transaction remains open (on the same+** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT+** is returned. If another error code - for example SQLITE_PROTOCOL or an+** SQLITE_IOERR error code - is returned, then the final state of the+** read transaction is undefined. If SQLITE_OK is returned, then the +** read transaction is now open on database snapshot P.+** ** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the ** database connection D does not know that the database file for ** schema S is in [WAL mode]. A database connection might not know@@ -8942,7 +9182,7 @@ ** database connection in order to make it ready to use snapshots.) ** ** The [sqlite3_snapshot_open()] interface is only available when the-** SQLITE_ENABLE_SNAPSHOT compile-time option is used.+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. */ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open( sqlite3 *db,@@ -8952,20 +9192,20 @@ /* ** CAPI3REF: Destroy a snapshot-** EXPERIMENTAL+** DESTRUCTOR: sqlite3_snapshot ** ** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P. ** The application must eventually free every [sqlite3_snapshot] object ** using this routine to avoid a memory leak. ** ** The [sqlite3_snapshot_free()] interface is only available when the-** SQLITE_ENABLE_SNAPSHOT compile-time option is used.+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. */ SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*); /* ** CAPI3REF: Compare the ages of two snapshot handles.-** EXPERIMENTAL+** METHOD: sqlite3_snapshot ** ** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages ** of two valid snapshot handles. @@ -8984,6 +9224,9 @@ ** Otherwise, this API returns a negative value if P1 refers to an older ** snapshot than P2, zero if the two handles refer to the same database ** snapshot, and a positive value if P1 is a newer snapshot than P2.+**+** This interface is only available if SQLite is compiled with the+** [SQLITE_ENABLE_SNAPSHOT] option. */ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp( sqlite3_snapshot *p1,@@ -8992,23 +9235,26 @@ /* ** CAPI3REF: Recover snapshots from a wal file-** EXPERIMENTAL+** METHOD: sqlite3_snapshot **-** If all connections disconnect from a database file but do not perform-** a checkpoint, the existing wal file is opened along with the database-** file the next time the database is opened. At this point it is only-** possible to successfully call sqlite3_snapshot_open() to open the most-** recent snapshot of the database (the one at the head of the wal file),-** even though the wal file may contain other valid snapshots for which-** clients have sqlite3_snapshot handles.+** If a [WAL file] remains on disk after all database connections close+** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control]+** or because the last process to have the database opened exited without+** calling [sqlite3_close()]) and a new connection is subsequently opened+** on that database and [WAL file], the [sqlite3_snapshot_open()] interface+** will only be able to open the last transaction added to the WAL file+** even though the WAL file contains other valid transactions. **-** This function attempts to scan the wal file associated with database zDb+** This function attempts to scan the WAL file associated with database zDb ** of database handle db and make all valid snapshots available to ** sqlite3_snapshot_open(). It is an error if there is already a read-** transaction open on the database, or if the database is not a wal mode+** transaction open on the database, or if the database is not a WAL mode ** database. ** ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.+**+** This interface is only available if SQLite is compiled with the+** [SQLITE_ENABLE_SNAPSHOT] option. */ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb); @@ -9119,7 +9365,7 @@ ** in the P argument is held in memory obtained from [sqlite3_malloc64()] ** and that SQLite should take ownership of this memory and automatically ** free it when it has finished using it. Without this flag, the caller-** is resposible for freeing any dynamically allocated memory.+** is responsible for freeing any dynamically allocated memory. ** ** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to ** grow the size of the database using calls to [sqlite3_realloc64()]. This@@ -9245,7 +9491,7 @@ sqlite3_int64 iRowid; /* Rowid for current entry */ sqlite3_rtree_dbl rParentScore; /* Score of parent node */ int eParentWithin; /* Visibility of parent node */- int eWithin; /* OUT: Visiblity */+ int eWithin; /* OUT: Visibility */ sqlite3_rtree_dbl rScore; /* OUT: Write the score here */ /* The following fields are only available in 3.8.11 and later */ sqlite3_value **apSqlParam; /* Original SQL values of parameters */@@ -9741,14 +9987,40 @@ ** consecutively. There is no chance that the iterator will visit a change ** the applies to table X, then one for table Y, and then later on visit ** another change for table X.+**+** The behavior of sqlite3changeset_start_v2() and its streaming equivalent+** may be modified by passing a combination of+** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter.+**+** Note that the sqlite3changeset_start_v2() API is still <b>experimental</b>+** and therefore subject to change. */ SQLITE_API int sqlite3changeset_start( sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ int nChangeset, /* Size of changeset blob in bytes */ void *pChangeset /* Pointer to blob containing changeset */ );+SQLITE_API int sqlite3changeset_start_v2(+ sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */+ int nChangeset, /* Size of changeset blob in bytes */+ void *pChangeset, /* Pointer to blob containing changeset */+ int flags /* SESSION_CHANGESETSTART_* flags */+); +/*+** CAPI3REF: Flags for sqlite3changeset_start_v2+**+** The following flags may passed via the 4th parameter to+** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]:+**+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>+** Invert the changeset while iterating through it. This is equivalent to+** inverting a changeset using sqlite3changeset_invert() before applying it.+** It is an error to specify this flag with a patchset.+*/+#define SQLITE_CHANGESETSTART_INVERT 0x0002 + /* ** CAPI3REF: Advance A Changeset Iterator ** METHOD: sqlite3_changeset_iter@@ -9790,7 +10062,7 @@ ** sqlite3changeset_next() is called on the iterator or until the ** conflict-handler function returns. If pnCol is not NULL, then *pnCol is ** set to the number of columns in the table affected by the change. If-** pbIncorrect is not NULL, then *pbIndirect is set to true (1) if the change+** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change ** is an indirect change, or false (0) otherwise. See the documentation for ** [sqlite3session_indirect()] for a description of direct and indirect ** changes. Finally, if pOp is not NULL, then *pOp is set to one of @@ -10401,7 +10673,7 @@ ), void *pCtx, /* First argument passed to xConflict */ void **ppRebase, int *pnRebase, /* OUT: Rebase data */- int flags /* Combination of SESSION_APPLY_* flags */+ int flags /* SESSION_CHANGESETAPPLY_* flags */ ); /*@@ -10419,8 +10691,14 @@ ** causes the sessions module to omit this savepoint. In this case, if the ** caller has an open transaction or savepoint when apply_v2() is called, ** it may revert the partially applied changeset by rolling it back.+**+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>+** Invert the changeset before applying it. This is equivalent to inverting+** a changeset using sqlite3changeset_invert() before applying it. It is+** an error to specify this flag with a patchset. */ #define SQLITE_CHANGESETAPPLY_NOSAVEPOINT 0x0001+#define SQLITE_CHANGESETAPPLY_INVERT 0x0002 /* ** CAPI3REF: Constants Passed To The Conflict Handler@@ -10651,7 +10929,7 @@ ** in size. This function allocates and populates a buffer with a copy ** of the changeset rebased rebased according to the configuration of the ** rebaser object passed as the first argument. If successful, (*ppOut)-** is set to point to the new buffer containing the rebased changset and +** is set to point to the new buffer containing the rebased changeset and ** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the ** responsibility of the caller to eventually free the new buffer using ** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut)@@ -10814,6 +11092,12 @@ int (*xInput)(void *pIn, void *pData, int *pnData), void *pIn );+SQLITE_API int sqlite3changeset_start_v2_strm(+ sqlite3_changeset_iter **pp,+ int (*xInput)(void *pIn, void *pData, int *pnData),+ void *pIn,+ int flags+); SQLITE_API int sqlite3session_changeset_strm( sqlite3_session *pSession, int (*xOutput)(void *pOut, const void *pData, int nData),@@ -10840,8 +11124,47 @@ void *pOut ); +/*+** CAPI3REF: Configure global parameters+**+** The sqlite3session_config() interface is used to make global configuration+** changes to the sessions module in order to tune it to the specific needs +** of the application.+**+** The sqlite3session_config() interface is not threadsafe. If it is invoked+** while any other thread is inside any other sessions method then the+** results are undefined. Furthermore, if it is invoked after any sessions+** related objects have been created, the results are also undefined. +**+** The first argument to the sqlite3session_config() function must be one+** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The +** interpretation of the (void*) value passed as the second parameter and+** the effect of calling this function depends on the value of the first+** parameter.+**+** <dl>+** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd>+** By default, the sessions module streaming interfaces attempt to input+** and output data in approximately 1 KiB chunks. This operand may be used+** to set and query the value of this configuration setting. The pointer+** passed as the second argument must point to a value of type (int).+** If this value is greater than 0, it is used as the new streaming data+** chunk size for both input and output. Before returning, the (int) value+** pointed to by pArg is set to the final value of the streaming interface+** chunk size.+** </dl>+**+** This function returns SQLITE_OK if successful, or an SQLite error code+** otherwise.+*/+SQLITE_API int sqlite3session_config(int op, void *pArg); /*+** CAPI3REF: Values for sqlite3session_config().+*/+#define SQLITE_SESSION_CONFIG_STRMSIZE 1++/* ** Make sure we can call this stuff from C++. */ #ifdef __cplusplus@@ -10973,12 +11296,8 @@ ** ** Usually, output parameter *piPhrase is set to the phrase number, *piCol ** to the column in which it occurs and *piOff the token offset of the-** first token of the phrase. The exception is if the table was created-** with the offsets=0 option specified. In this case *piOff is always-** set to -1.-**-** Returns SQLITE_OK if successful, or an error code (i.e. SQLITE_NOMEM) -** if an error occurs.+** first token of the phrase. Returns SQLITE_OK if successful, or an error+** code (i.e. SQLITE_NOMEM) if an error occurs. ** ** This API can be quite slow if used with an FTS5 table created with the ** "detail=none" or "detail=column" option. @@ -11019,7 +11338,7 @@ ** Save the pointer passed as the second argument as the extension functions ** "auxiliary data". The pointer may then be retrieved by the current or any ** future invocation of the same fts5 extension function made as part of-** of the same MATCH query using the xGetAuxdata() API.+** the same MATCH query using the xGetAuxdata() API. ** ** Each extension function is allocated a single auxiliary data slot for ** each FTS query (MATCH expression). If the extension function is invoked @@ -11034,7 +11353,7 @@ ** The xDelete callback, if one is specified, is also invoked on the ** auxiliary data pointer after the FTS5 query has finished. **-** If an error (e.g. an OOM condition) occurs within this function, an+** If an error (e.g. an OOM condition) occurs within this function, ** the auxiliary data is set to NULL and an error code returned. If the ** xDelete parameter was not NULL, it is invoked on the auxiliary data ** pointer before returning.@@ -11267,11 +11586,11 @@ ** the tokenizer substitutes "first" for "1st" and the query works ** as expected. **-** <li> By adding multiple synonyms for a single term to the FTS index.-** In this case, when tokenizing query text, the tokenizer may -** provide multiple synonyms for a single term within the document.-** FTS5 then queries the index for each synonym individually. For-** example, faced with the query:+** <li> By querying the index for all synonyms of each query term+** separately. In this case, when tokenizing query text, the+** tokenizer may provide multiple synonyms for a single term +** within the document. FTS5 then queries the index for each +** synonym individually. For example, faced with the query: ** ** <codeblock> ** ... MATCH 'first place'</codeblock>@@ -11295,9 +11614,9 @@ ** "place". ** ** This way, even if the tokenizer does not provide synonyms-** when tokenizing query text (it should not - to do would be+** when tokenizing query text (it should not - to do so would be ** inefficient), it doesn't matter if the user queries for -** 'first + place' or '1st + place', as there are entires in the+** 'first + place' or '1st + place', as there are entries in the ** FTS index corresponding to both forms of the first token. ** </ol> **@@ -11325,7 +11644,7 @@ ** extra data to the FTS index or require FTS5 to query for multiple terms, ** so it is efficient in terms of disk space and query speed. However, it ** does not support prefix queries very well. If, as suggested above, the-** token "first" is subsituted for "1st" by the tokenizer, then the query:+** token "first" is substituted for "1st" by the tokenizer, then the query: ** ** <codeblock> ** ... MATCH '1s*'</codeblock>
cbits/sqlite3ext.h view
@@ -310,6 +310,18 @@ int (*str_errcode)(sqlite3_str*); int (*str_length)(sqlite3_str*); char *(*str_value)(sqlite3_str*);+ /* Version 3.25.0 and later */+ int (*create_window_function)(sqlite3*,const char*,int,int,void*,+ void (*xStep)(sqlite3_context*,int,sqlite3_value**),+ void (*xFinal)(sqlite3_context*),+ void (*xValue)(sqlite3_context*),+ void (*xInv)(sqlite3_context*,int,sqlite3_value**),+ void(*xDestroy)(void*));+ /* Version 3.26.0 and later */+ const char *(*normalized_sql)(sqlite3_stmt*);+ /* Version 3.28.0 and later */+ int (*stmt_isexplain)(sqlite3_stmt*);+ int (*value_frombind)(sqlite3_value*); }; /*@@ -595,6 +607,13 @@ #define sqlite3_str_errcode sqlite3_api->str_errcode #define sqlite3_str_length sqlite3_api->str_length #define sqlite3_str_value sqlite3_api->str_value+/* Version 3.25.0 and later */+#define sqlite3_create_window_function sqlite3_api->create_window_function+/* Version 3.26.0 and later */+#define sqlite3_normalized_sql sqlite3_api->normalized_sql+/* Version 3.28.0 and later */+#define sqlite3_stmt_isexplain sqlite3_api->isexplain+#define sqlite3_value_frombind sqlite3_api->frombind #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
changelog view
@@ -1,3 +1,9 @@+v2.3.26:+ * Add support for GHC 8.8 and Stackage LTS 15+++v2.3.25:+ * Upgrade embedded sqlite library to 3.28.0.+ v2.3.24: * Upgrade embedded sqlite3 library to 3.24.0. * Add faster `stepNoCB` function for statements that don't callback to Haskell functions.@@ -170,4 +176,3 @@ * Adds the SQLite amalgamation file (version 3.7.5) to the project, so that there are no external dependencies.-
direct-sqlite.cabal view
@@ -1,5 +1,5 @@ name: direct-sqlite-version: 2.3.24+version: 2.3.26 synopsis: Low-level binding to SQLite3. Includes UTF8 and BLOB support. description: This package is not very different from the other SQLite3 bindings out there, but it fixes a few deficiencies I was finding. As compared to@@ -10,8 +10,8 @@ license: BSD3 license-file: LICENSE copyright: Copyright (c) 2012 - 2014 Irene Knapp,- 2014 - 2018 Janne Hellsten,- 2018 - 2019 Sergey Bushnyak+ 2014 - 2018 Janne Hellsten,+ 2018 - 2020 Sergey Bushnyak author: Irene Knapp <irene.knapp@icloud.com> maintainer: Sergey Bushnyak <sergey.bushnyak@sigrlami.eu> category: Database@@ -55,7 +55,7 @@ Database.SQLite3.Direct build-depends: base >= 4.1 && < 5 , bytestring >= 0.9.2.1- , semigroups >= 0.18 && < 0.19+ , semigroups >= 0.18 && < 0.20 , text >= 0.11 default-language: Haskell2010 include-dirs: .