From 8ef5e3c50a34b84d6097e994e5d21ff99f081ece Mon Sep 17 00:00:00 2001 From: Eduardo DAVILA Date: Wed, 5 Jun 2013 16:24:21 +0200 Subject: [PATCH] 2018 BUG Take out the SQLite(dll lib h) from source and put it in creaThirdPartyLibrary mechanism --- win32/CMakeLists.txt | 30 - win32/sqlite3.dll | Bin 409600 -> 0 bytes win32/sqlite3.h | 5734 -- win32/sqlite3.lib | Bin 41644 -> 0 bytes win64/CMakeLists.txt | 30 - win64/sqlite/CMakeLists.txt | 37 - win64/sqlite/Readme.txt | 18 - win64/sqlite/shell.c | 2635 - win64/sqlite/sqlite3.c | 112444 --------------------------------- win64/sqlite/sqlite3.def | 183 - win64/sqlite/sqlite3.h | 5734 -- win64/sqlite/sqlite3ext.h | 378 - win64/sqlite3.dll | Bin 875520 -> 0 bytes win64/sqlite3.h | 5734 -- win64/sqlite3.lib | Bin 40776 -> 0 bytes 15 files changed, 132957 deletions(-) delete mode 100644 win32/CMakeLists.txt delete mode 100644 win32/sqlite3.dll delete mode 100644 win32/sqlite3.h delete mode 100644 win32/sqlite3.lib delete mode 100644 win64/CMakeLists.txt delete mode 100644 win64/sqlite/CMakeLists.txt delete mode 100644 win64/sqlite/Readme.txt delete mode 100644 win64/sqlite/shell.c delete mode 100644 win64/sqlite/sqlite3.c delete mode 100644 win64/sqlite/sqlite3.def delete mode 100644 win64/sqlite/sqlite3.h delete mode 100644 win64/sqlite/sqlite3ext.h delete mode 100644 win64/sqlite3.dll delete mode 100644 win64/sqlite3.h delete mode 100644 win64/sqlite3.lib diff --git a/win32/CMakeLists.txt b/win32/CMakeLists.txt deleted file mode 100644 index 0903896..0000000 --- a/win32/CMakeLists.txt +++ /dev/null @@ -1,30 +0,0 @@ -# --------------------------------------------------------------------- -# -# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image -# pour la Santé) -# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton -# Previous Authors : Laurent Guigues, Jean-Pierre Roux -# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil -# -# This software is governed by the CeCILL-B license under French law and -# abiding by the rules of distribution of free software. You can use, -# modify and/ or redistribute the software under the terms of the CeCILL-B -# license as circulated by CEA, CNRS and INRIA at the following URL -# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html -# or in the file LICENSE.txt. -# -# As a counterpart to the access to the source code and rights to copy, -# modify and redistribute granted by the license, users are provided only -# with a limited warranty and the software's author, the holder of the -# economic rights, and the successive licensors have only limited -# liability. -# -# The fact that you are presently reading this means that you have had -# knowledge of the CeCILL-B license and that you accept its terms. -# ------------------------------------------------------------------------ - -IF (WIN32) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Debug/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/Release/sqlite3.dll COPYONLY) - configure_file(sqlite3.dll ${PROJECT_BINARY_DIR}/RelWithDebInfo/sqlite3.dll COPYONLY) -ENDIF(WIN32) \ No newline at end of file diff --git a/win32/sqlite3.dll b/win32/sqlite3.dll deleted file mode 100644 index 7b07c55bdac316471e468a1631717f128f8c84f0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 409600 zcmeFae|QtunJ{`JjpV@|m;q!Epn#H0QYVJQsYqfYhsq$!B5{m_Z3)&`O4HN@mnH;e zfNX>A3L={DcjUul}}rn}v3+GYjGc8P?HjEPIY*#w9~LegzJU}y|9vJHW` z&wFNM>?Hj*-`@K?_n&*72W#fc`SG6job#Ud=i&ap*^Mj+AqpX+X$b8_dh!~-|GRVw zAv9yrD>Kkb(|&jTUQ_+=u5a3~ajR?dmPfv}<;&l2edWs!Km3T`dhn~RE#kwjjSstg zs~cV4c;un4-Zp)DF>f?X-#+queZ!CPg@3hoP0u$p{3u_0S4qB({LUxuU+?}yel;og zeDC{uJ*WWnNo9l*Gi<236rmp! z*-$lP25sm?v;KWbdccN$d;OH0&rC1cY*XiCw-tF!pIMZo+k~&~5MW*fV_Yy+nB+;x zh0p`HZF%U+!j}>H?cWLHWEx!Cm#WQiC0YMn5{>^_?`wnVf_ zuWQ3a(pb3|!k3dxJh!GDwR_r8yE*CO7YEyywa;irmW%D?u=BE%Hawq;A#v@4|&jlyItLI&z_GRr3 zfHkZJt^voKJWi%Q3OJK;*2MBjop_%@!Iiz#mCb2zdv#4c)wmxeCy0X zuI?7o$(T!7?NDzf&{1-lm6vFmR#oSWvQO{tj+Dc&CQtuBDA92%V&zM4By^Oa#^wmy z^&zb9hZ*UL8F$b)%5_q!r31{~Me=ZH^ux?0D?XGty~uJX*=*W482Tp)?fqvwv|;p2 z<`RR?WX>(JoJsz}rdbGW9Q@}e5z?!jfohj5XK>~j=>tpV!$p?;nK85Fie;>PJn36x zR(w1&K~)H-SD zY)n6J2BBy07=By*^Ovotd~CtnrsXrERHCCC2@9~_X_UCdmh+dPoc|Uy4;n2;vDTJ# z*?)(X|LTz_kh#c!X>bk+uvg>v<=c5wataKHd(?Yf)pn z8FqZAeMvh5&rST&HSJ3_uwOu^9ko-<>dpi#s-{I--RTyom&uYn2M>jT87TzYpGoX2L##}j5K8R46^RbA2l{GhK!{SyD79R7 zZCUHOEUrcPeyTAXX-8Ic+uxfvp!GLfrK2bmR4+bYMR-IJc*l^Bcf4~`CCuZU6)=xw z@aZ5-Jel?KgUOff_{fUTwZdhjunP)bjzQs#{jhcvAMeoD&uOxLVBK88ZEIz2nMyo_o8V=hT;CR#ZMxJ}O{^r53j&S6+-om0Cs`GXphj z>0qtjJ*R0(EuE_^GqtYETA!ZsN-z`(;}KYcto$@WNd4W%nucw-f%-H8e)@nF0H%g~ zJoV0<-lJCTL|R=!Mzi<8Z+`mJ=xNK*%%u{%Kcg

{tBujp>o|nx@qAl;z-FrMtWP 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%0DCI8G3e#t|JevsLBst7u%AINfIP0o#7C@`UdP^ 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ξ3h8+kpzl9#hI?_9d}CXNh3-Ez4O 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

jYJPc?TM-`L_-vVPofymcat*l=&sEbj?!|y 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 diff --git a/win32/sqlite3.h b/win32/sqlite3.h deleted file mode 100644 index d72fdbd..0000000 --- a/win32/sqlite3.h +++ /dev/null @@ -1,5734 +0,0 @@ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the SQLite library -** presents to client programs. If a C-function, structure, datatype, -** or constant definition does not appear in this file, then it is -** not a published API of SQLite, is subject to change without -** notice, and should not be referenced by programs that use SQLite. -** -** Some of the definitions that are in this file are marked as -** "experimental". Experimental interfaces are normally new -** features recently added to SQLite. We do not anticipate changes -** to experimental interfaces but reserve the right to make minor changes -** if experience from use "in the wild" suggest such changes are prudent. -** -** The official C-language API documentation for SQLite is derived -** from comments in this file. This file is the authoritative source -** on how SQLite interfaces are suppose to operate. -** -** The name of this file under configuration management is "sqlite.h.in". -** The makefile makes some minor changes to this file (such as inserting -** the version number) and changes its name to "sqlite3.h" as -** part of the build process. -*/ -#ifndef _SQLITE3_H_ -#define _SQLITE3_H_ -#include /* Needed for the definition of va_list */ - -/* -** Make sure we can call this stuff from C++. -*/ -#ifdef __cplusplus -extern "C" { -#endif - - -/* -** Add the ability to override 'extern' -*/ -#ifndef SQLITE_EXTERN -# define SQLITE_EXTERN extern -#endif - -#ifndef SQLITE_API -# define SQLITE_API -#endif - - -/* -** These no-op macros are used in front of interfaces to mark those -** interfaces as either deprecated or experimental. New applications -** should not use deprecated interfaces - they are support for backwards -** compatibility only. Application writers should be aware that -** experimental interfaces are subject to change in point releases. -** -** These macros used to resolve to various kinds of compiler magic that -** would generate warning messages when they were used. But that -** compiler magic ended up generating such a flurry of bug reports -** that we have taken it all out and gone back to using simple -** noop macros. -*/ -#define SQLITE_DEPRECATED -#define SQLITE_EXPERIMENTAL - -/* -** Ensure these symbols were not defined by some previous header file. -*/ -#ifdef SQLITE_VERSION -# undef SQLITE_VERSION -#endif -#ifdef SQLITE_VERSION_NUMBER -# undef SQLITE_VERSION_NUMBER -#endif - -/* -** CAPI3REF: Compile-Time Library Version Numbers -** -** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header -** evaluates to a string literal that is the SQLite version in the -** format "X.Y.Z" where X is the major version number (always 3 for -** SQLite3) and Y is the minor version number and Z is the release number.)^ -** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer -** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same -** numbers used in [SQLITE_VERSION].)^ -** The SQLITE_VERSION_NUMBER for any given release of SQLite will also -** be larger than the release from which it is derived. Either Y will -** be held constant and Z will be incremented or else Y will be incremented -** and Z will be reset to zero. -** -** Since version 3.6.18, SQLite source code has been stored in the -** Fossil configuration management -** system. ^The SQLITE_SOURCE_ID macro evalutes to -** a string which identifies a particular check-in of SQLite -** within its configuration management system. ^The SQLITE_SOURCE_ID -** 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()]. -*/ -#define SQLITE_VERSION "3.6.23.1" -#define SQLITE_VERSION_NUMBER 3006023 -#define SQLITE_SOURCE_ID "2010-03-26 22:28:06 b078b588d617e07886ad156e9f54ade6d823568e" - -/* -** CAPI3REF: Run-Time Library Version Numbers -** KEYWORDS: sqlite3_version, sqlite3_sourceid -** -** These interfaces provide the same information as the [SQLITE_VERSION], -** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros -** but are associated with the library instead of the header file. ^(Cautious -** programmers might include assert() statements in their application to -** verify that values returned by these interfaces match the macros in -** the header, and thus insure that the application is -** compiled with matching library and header files. -** -** 

-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
-** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
-**
)^ -** -** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] -** macro. ^The sqlite3_libversion() function returns a pointer to the -** to the sqlite3_version[] string constant. The sqlite3_libversion() -** function is provided for use in DLLs since DLL users usually do not have -** direct access to string constants within the DLL. ^The -** sqlite3_libversion_number() function returns an integer equal to -** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns -** a pointer to a string constant whose value is the same as the -** [SQLITE_SOURCE_ID] C preprocessor macro. -** -** See also: [sqlite_version()] and [sqlite_source_id()]. -*/ -SQLITE_API SQLITE_EXTERN const char sqlite3_version[]; -SQLITE_API const char *sqlite3_libversion(void); -SQLITE_API const char *sqlite3_sourceid(void); -SQLITE_API int sqlite3_libversion_number(void); - -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS -/* -** CAPI3REF: Run-Time Library Compilation Options Diagnostics -** -** ^The sqlite3_compileoption_used() function returns 0 or 1 -** indicating whether the specified option was defined at -** compile time. ^The SQLITE_ prefix may be omitted from the -** option name passed to sqlite3_compileoption_used(). -** -** ^The sqlite3_compileoption_get() function allows interating -** over the list of options that were defined at compile time by -** returning the N-th compile time option string. ^If N is out of range, -** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ -** prefix is omitted from any strings returned by -** sqlite3_compileoption_get(). -** -** ^Support for the diagnostic functions sqlite3_compileoption_used() -** and sqlite3_compileoption_get() may be omitted by specifing the -** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. -** -** See also: SQL functions [sqlite_compileoption_used()] and -** [sqlite_compileoption_get()] and the [compile_options pragma]. -*/ -SQLITE_API int sqlite3_compileoption_used(const char *zOptName); -SQLITE_API const char *sqlite3_compileoption_get(int N); -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ - -/* -** CAPI3REF: Test To See If The Library Is Threadsafe -** -** ^The sqlite3_threadsafe() function returns zero if and only if -** SQLite was compiled mutexing code omitted due to the -** [SQLITE_THREADSAFE] compile-time option being set to 0. -** -** SQLite can be compiled with or without mutexes. When -** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes -** are enabled and SQLite is threadsafe. When the -** [SQLITE_THREADSAFE] macro is 0, -** the mutexes are omitted. Without the mutexes, it is not safe -** to use SQLite concurrently from more than one thread. -** -** Enabling mutexes incurs a measurable performance penalty. -** So if speed is of utmost importance, it makes sense to disable -** the mutexes. But for maximum safety, mutexes should be enabled. -** ^The default behavior is for mutexes to be enabled. -** -** This interface can be used by an application to make sure that the -** version of SQLite that it is linking against was compiled with -** the desired setting of the [SQLITE_THREADSAFE] macro. -** -** This interface only reports on the compile-time mutex setting -** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with -** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but -** can be fully or partially disabled using a call to [sqlite3_config()] -** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], -** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the -** sqlite3_threadsafe() function shows only the compile-time setting of -** thread safety, not any run-time changes to that setting made by -** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() -** is unchanged by calls to sqlite3_config().)^ -** -** See the [threading mode] documentation for additional information. -*/ -SQLITE_API int sqlite3_threadsafe(void); - -/* -** CAPI3REF: Database Connection Handle -** KEYWORDS: {database connection} {database connections} -** -** Each open SQLite database is represented by a pointer to an instance of -** the opaque structure named "sqlite3". It is useful to think of an sqlite3 -** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and -** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] -** is its destructor. There are many other interfaces (such as -** [sqlite3_prepare_v2()], [sqlite3_create_function()], and -** [sqlite3_busy_timeout()] to name but three) that are methods on an -** sqlite3 object. -*/ -typedef struct sqlite3 sqlite3; - -/* -** CAPI3REF: 64-Bit Integer Types -** KEYWORDS: sqlite_int64 sqlite_uint64 -** -** Because there is no cross-platform way to specify 64-bit integer types -** SQLite includes typedefs for 64-bit signed and unsigned integers. -** -** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. -** The sqlite_int64 and sqlite_uint64 types are supported for backwards -** compatibility only. -** -** ^The sqlite3_int64 and sqlite_int64 types can store integer values -** between -9223372036854775808 and +9223372036854775807 inclusive. ^The -** sqlite3_uint64 and sqlite_uint64 types can store integer values -** between 0 and +18446744073709551615 inclusive. -*/ -#ifdef SQLITE_INT64_TYPE - typedef SQLITE_INT64_TYPE sqlite_int64; - typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; -#elif defined(_MSC_VER) || defined(__BORLANDC__) - typedef __int64 sqlite_int64; - typedef unsigned __int64 sqlite_uint64; -#else - typedef long long int sqlite_int64; - typedef unsigned long long int sqlite_uint64; -#endif -typedef sqlite_int64 sqlite3_int64; -typedef sqlite_uint64 sqlite3_uint64; - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite3_int64 -#endif - -/* -** CAPI3REF: Closing A Database Connection -** -** ^The sqlite3_close() routine is the destructor for the [sqlite3] object. -** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is -** successfullly destroyed and all associated resources are deallocated. -** -** Applications must [sqlite3_finalize | finalize] all [prepared statements] -** and [sqlite3_blob_close | close] all [BLOB handles] associated with -** the [sqlite3] object prior to attempting to close the object. ^If -** sqlite3_close() is called on a [database connection] that still has -** outstanding [prepared statements] or [BLOB handles], then it returns -** SQLITE_BUSY. -** -** ^If [sqlite3_close()] is invoked while a transaction is open, -** the transaction is automatically rolled back. -** -** The C parameter to [sqlite3_close(C)] must be either a NULL -** pointer or an [sqlite3] object pointer obtained -** from [sqlite3_open()], [sqlite3_open16()], or -** [sqlite3_open_v2()], and not previously closed. -** ^Calling sqlite3_close() with a NULL pointer argument is a -** harmless no-op. -*/ -SQLITE_API int sqlite3_close(sqlite3 *); - -/* -** The type for a callback function. -** This is legacy and deprecated. It is included for historical -** compatibility and is not documented. -*/ -typedef int (*sqlite3_callback)(void*,int,char**, char**); - -/* -** CAPI3REF: One-Step Query Execution Interface -** -** The sqlite3_exec() interface is a convenience wrapper around -** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], -** that allows an application to run multiple statements of SQL -** without having to use a lot of C code. -** -** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, -** semicolon-separate SQL statements passed into its 2nd argument, -** in the context of the [database connection] passed in as its 1st -** argument. ^If the callback function of the 3rd argument to -** sqlite3_exec() is not NULL, then it is invoked for each result row -** coming out of the evaluated SQL statements. ^The 4th argument to -** to sqlite3_exec() is relayed through to the 1st argument of each -** callback invocation. ^If the callback pointer to sqlite3_exec() -** is NULL, then no callback is ever invoked and result rows are -** ignored. -** -** ^If an error occurs while evaluating the SQL statements passed into -** sqlite3_exec(), then execution of the current statement stops and -** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() -** is not NULL then any error message is written into memory obtained -** from [sqlite3_malloc()] and passed back through the 5th parameter. -** To avoid memory leaks, the application should invoke [sqlite3_free()] -** on error message strings returned through the 5th parameter of -** of sqlite3_exec() after the error message string is no longer needed. -** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors -** occur, then sqlite3_exec() sets the pointer in its 5th parameter to -** NULL before returning. -** -** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() -** routine returns SQLITE_ABORT without invoking the callback again and -** without running any subsequent SQL statements. -** -** ^The 2nd argument to the sqlite3_exec() callback function is the -** number of columns in the result. ^The 3rd argument to the sqlite3_exec() -** callback is an array of pointers to strings obtained as if from -** [sqlite3_column_text()], one for each column. ^If an element of a -** result row is NULL then the corresponding string pointer for the -** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the -** sqlite3_exec() callback is an array of pointers to strings where each -** entry represents the name of corresponding result column as obtained -** from [sqlite3_column_name()]. -** -** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer -** to an empty string, or a pointer that contains only whitespace and/or -** SQL comments, then no SQL statements are evaluated and the database -** is not changed. -** -** Restrictions: -** -**
    -**
  • The application must insure that the 1st parameter to sqlite3_exec() -** is a valid and open [database connection]. -**
  • The application must not close [database connection] specified by -** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. -**
  • The application must not modify the SQL statement text passed into -** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. -**
-*/ -SQLITE_API int sqlite3_exec( - sqlite3*, /* An open database */ - const char *sql, /* SQL to be evaluated */ - int (*callback)(void*,int,char**,char**), /* Callback function */ - void *, /* 1st argument to callback */ - char **errmsg /* Error msg written here */ -); - -/* -** CAPI3REF: Result Codes -** KEYWORDS: SQLITE_OK {error code} {error codes} -** KEYWORDS: {result code} {result codes} -** -** Many SQLite functions return an integer result code from the set shown -** here in order to indicates success or failure. -** -** New error codes may be added in future versions of SQLite. -** -** See also: [SQLITE_IOERR_READ | extended result codes] -*/ -#define SQLITE_OK 0 /* Successful result */ -/* beginning-of-error-codes */ -#define SQLITE_ERROR 1 /* SQL error or missing database */ -#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ -#define SQLITE_PERM 3 /* Access permission denied */ -#define SQLITE_ABORT 4 /* Callback routine requested an abort */ -#define SQLITE_BUSY 5 /* The database file is locked */ -#define SQLITE_LOCKED 6 /* A table in the database is locked */ -#define SQLITE_NOMEM 7 /* A malloc() failed */ -#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ -#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ -#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ -#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ -#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ -#define SQLITE_FULL 13 /* Insertion failed because database is full */ -#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ -#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ -#define SQLITE_EMPTY 16 /* Database is empty */ -#define SQLITE_SCHEMA 17 /* The database schema changed */ -#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ -#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ -#define SQLITE_MISMATCH 20 /* Data type mismatch */ -#define SQLITE_MISUSE 21 /* Library used incorrectly */ -#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ -#define SQLITE_AUTH 23 /* Authorization denied */ -#define SQLITE_FORMAT 24 /* Auxiliary database format error */ -#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ -#define SQLITE_NOTADB 26 /* File opened that is not a database file */ -#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ -#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ -/* end-of-error-codes */ - -/* -** CAPI3REF: Extended Result Codes -** KEYWORDS: {extended error code} {extended error codes} -** KEYWORDS: {extended result code} {extended result codes} -** -** In its default configuration, SQLite API routines return one of 26 integer -** [SQLITE_OK | result codes]. However, experience has shown that many of -** these result codes are too coarse-grained. They do not provide as -** much information about problems as programmers might like. In an effort to -** address this, newer versions of SQLite (version 3.3.8 and later) include -** support for additional result codes that provide more detailed information -** about errors. The extended result codes are enabled or disabled -** on a per database connection basis using the -** [sqlite3_extended_result_codes()] API. -** -** Some of the available extended result codes are listed here. -** One may expect the number of extended result codes will be expand -** over time. Software that uses extended result codes should expect -** to see new result codes in future releases of SQLite. -** -** The SQLITE_OK result code will never be extended. It will always -** be exactly zero. -*/ -#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)) -#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) -#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) -#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) -#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) -#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) -#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) -#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) -#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) -#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) -#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) -#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) -#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) -#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) -#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) -#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8) ) - -/* -** CAPI3REF: Flags For File Open Operations -** -** These bit values are intended for use in the -** 3rd parameter to the [sqlite3_open_v2()] interface and -** in the 4th parameter to the xOpen method of the -** [sqlite3_vfs] object. -*/ -#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ -#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ -#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ -#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ -#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ -#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ -#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ -#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ -#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ -#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ -#define SQLITE_OPEN_NOMUTEX 0x00008000 /* 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 -** -** The xDeviceCapabilities method of the [sqlite3_io_methods] -** object returns an integer which is a vector of the these -** bit values expressing I/O characteristics of the mass storage -** device that holds the file that the [sqlite3_io_methods] -** refers to. -** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -*/ -#define SQLITE_IOCAP_ATOMIC 0x00000001 -#define SQLITE_IOCAP_ATOMIC512 0x00000002 -#define SQLITE_IOCAP_ATOMIC1K 0x00000004 -#define SQLITE_IOCAP_ATOMIC2K 0x00000008 -#define SQLITE_IOCAP_ATOMIC4K 0x00000010 -#define SQLITE_IOCAP_ATOMIC8K 0x00000020 -#define SQLITE_IOCAP_ATOMIC16K 0x00000040 -#define SQLITE_IOCAP_ATOMIC32K 0x00000080 -#define SQLITE_IOCAP_ATOMIC64K 0x00000100 -#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 -#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 - -/* -** CAPI3REF: File Locking Levels -** -** SQLite uses one of these integer values as the second -** argument to calls it makes to the xLock() and xUnlock() methods -** of an [sqlite3_io_methods] object. -*/ -#define SQLITE_LOCK_NONE 0 -#define SQLITE_LOCK_SHARED 1 -#define SQLITE_LOCK_RESERVED 2 -#define SQLITE_LOCK_PENDING 3 -#define SQLITE_LOCK_EXCLUSIVE 4 - -/* -** CAPI3REF: Synchronization Type Flags -** -** When SQLite invokes the xSync() method of an -** [sqlite3_io_methods] object it uses a combination of -** these integer values as the second argument. -** -** When the SQLITE_SYNC_DATAONLY flag is used, it means that the -** sync operation only needs to flush data to mass storage. Inode -** information need not be flushed. If the lower four bits of the flag -** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. -** If the lower four bits equal SQLITE_SYNC_FULL, that means -** to use Mac OS X style fullsync instead of fsync(). -*/ -#define SQLITE_SYNC_NORMAL 0x00002 -#define SQLITE_SYNC_FULL 0x00003 -#define SQLITE_SYNC_DATAONLY 0x00010 - -/* -** CAPI3REF: OS Interface Open File Handle -** -** An [sqlite3_file] object represents an open file in the -** [sqlite3_vfs | OS interface layer]. Individual OS interface -** implementations will -** want to subclass this object by appending additional fields -** for their own use. The pMethods entry is a pointer to an -** [sqlite3_io_methods] object that defines methods for performing -** I/O operations on the open file. -*/ -typedef struct sqlite3_file sqlite3_file; -struct sqlite3_file { - const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ -}; - -/* -** CAPI3REF: OS Interface File Virtual Methods Object -** -** Every file opened by the [sqlite3_vfs] xOpen method populates an -** [sqlite3_file] object (or, more commonly, a subclass of the -** [sqlite3_file] object) with a pointer to an instance of this object. -** This object defines the methods used to perform various operations -** against the open file represented by the [sqlite3_file] object. -** -** If the xOpen method sets the sqlite3_file.pMethods element -** to a non-NULL pointer, then the sqlite3_io_methods.xClose method -** may be invoked even if the xOpen reported that it failed. The -** only way to prevent a call to xClose following a failed xOpen -** is for the xOpen to set the sqlite3_file.pMethods element to NULL. -** -** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or -** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). -** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] -** flag may be ORed in to indicate that only the data of the file -** and not its inode needs to be synced. -** -** The integer values to xLock() and xUnlock() are one of -**
    -**
  • [SQLITE_LOCK_NONE], -**
  • [SQLITE_LOCK_SHARED], -**
  • [SQLITE_LOCK_RESERVED], -**
  • [SQLITE_LOCK_PENDING], or -**
  • [SQLITE_LOCK_EXCLUSIVE]. -**
-** xLock() increases the lock. xUnlock() decreases the lock. -** The xCheckReservedLock() method checks whether any database connection, -** either in this process or in some other process, is holding a RESERVED, -** PENDING, or EXCLUSIVE lock on the file. It returns true -** if such a lock exists and false otherwise. -** -** The xFileControl() method is a generic interface that allows custom -** VFS implementations to directly control an open file using the -** [sqlite3_file_control()] interface. The second "op" argument is an -** integer opcode. The third argument is a generic pointer intended to -** point to a structure that may contain arguments or space in which to -** write return values. Potential uses for xFileControl() might be -** functions to enable blocking locks with timeouts, to change the -** locking strategy (for example to use dot-file locks), to inquire -** about the status of a lock, or to break stale locks. The SQLite -** core reserves all opcodes less than 100 for its own use. -** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. -** Applications that define a custom xFileControl method should use opcodes -** greater than 100 to avoid conflicts. -** -** The xSectorSize() method returns the sector size of the -** device that underlies the file. The sector size is the -** minimum write that can be performed without disturbing -** other bytes in the file. The xDeviceCharacteristics() -** method returns a bit vector describing behaviors of the -** underlying device: -** -**
    -**
  • [SQLITE_IOCAP_ATOMIC] -**
  • [SQLITE_IOCAP_ATOMIC512] -**
  • [SQLITE_IOCAP_ATOMIC1K] -**
  • [SQLITE_IOCAP_ATOMIC2K] -**
  • [SQLITE_IOCAP_ATOMIC4K] -**
  • [SQLITE_IOCAP_ATOMIC8K] -**
  • [SQLITE_IOCAP_ATOMIC16K] -**
  • [SQLITE_IOCAP_ATOMIC32K] -**
  • [SQLITE_IOCAP_ATOMIC64K] -**
  • [SQLITE_IOCAP_SAFE_APPEND] -**
  • [SQLITE_IOCAP_SEQUENTIAL] -**
-** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -** -** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill -** in the unread portions of the buffer with zeros. A VFS that -** fails to zero-fill short reads might seem to work. However, -** failure to zero-fill short reads will eventually lead to -** database corruption. -*/ -typedef struct sqlite3_io_methods sqlite3_io_methods; -struct sqlite3_io_methods { - int iVersion; - int (*xClose)(sqlite3_file*); - int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); - int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); - int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); - int (*xSync)(sqlite3_file*, int flags); - int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); - int (*xLock)(sqlite3_file*, int); - int (*xUnlock)(sqlite3_file*, int); - int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); - int (*xFileControl)(sqlite3_file*, int op, void *pArg); - int (*xSectorSize)(sqlite3_file*); - int (*xDeviceCharacteristics)(sqlite3_file*); - /* Additional methods may be added in future releases */ -}; - -/* -** CAPI3REF: Standard File Control Opcodes -** -** These integer constants are opcodes for the xFileControl method -** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] -** interface. -** -** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This -** opcode causes the xFileControl method to write the current state of -** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], -** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) -** into an integer that the pArg argument points to. This capability -** is used during testing and only needs to be supported when SQLITE_TEST -** is defined. -*/ -#define SQLITE_FCNTL_LOCKSTATE 1 -#define SQLITE_GET_LOCKPROXYFILE 2 -#define SQLITE_SET_LOCKPROXYFILE 3 -#define SQLITE_LAST_ERRNO 4 - -/* -** CAPI3REF: Mutex Handle -** -** The mutex module within SQLite defines [sqlite3_mutex] to be an -** abstract type for a mutex object. The SQLite core never looks -** at the internal representation of an [sqlite3_mutex]. It only -** deals with pointers to the [sqlite3_mutex] object. -** -** Mutexes are created using [sqlite3_mutex_alloc()]. -*/ -typedef struct sqlite3_mutex sqlite3_mutex; - -/* -** CAPI3REF: OS Interface Object -** -** An instance of the sqlite3_vfs object defines the interface between -** the SQLite core and the underlying operating system. The "vfs" -** in the name of the object stands for "virtual file system". -** -** The value of the iVersion field is initially 1 but may be larger in -** future versions of SQLite. Additional fields may be appended to this -** object when the iVersion value is increased. Note that the structure -** of the sqlite3_vfs object changes in the transaction between -** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not -** modified. -** -** The szOsFile field is the size of the subclassed [sqlite3_file] -** structure used by this VFS. mxPathname is the maximum length of -** a pathname in this VFS. -** -** Registered sqlite3_vfs objects are kept on a linked list formed by -** the pNext pointer. The [sqlite3_vfs_register()] -** and [sqlite3_vfs_unregister()] interfaces manage this list -** in a thread-safe way. The [sqlite3_vfs_find()] interface -** searches the list. Neither the application code nor the VFS -** implementation should use the pNext pointer. -** -** The pNext field is the only field in the sqlite3_vfs -** structure that SQLite will ever modify. SQLite will only access -** or modify this field while holding a particular static mutex. -** The application should never modify anything within the sqlite3_vfs -** object once the object has been registered. -** -** The zName field holds the name of the VFS module. The name must -** be unique across all VFS modules. -** -** SQLite will guarantee that the zFilename parameter to xOpen -** is either a NULL pointer or string obtained -** from xFullPathname(). SQLite further guarantees that -** the string will be valid and unchanged until xClose() is -** called. Because of the previous sentence, -** the [sqlite3_file] can safely store a pointer to the -** filename if it needs to remember the filename for some reason. -** If the zFilename parameter is xOpen is a NULL pointer then xOpen -** must invent its own temporary name for the file. Whenever the -** xFilename parameter is NULL it will also be the case that the -** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. -** -** The flags argument to xOpen() includes all bits set in -** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] -** or [sqlite3_open16()] is used, then flags includes at least -** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. -** If xOpen() opens a file read-only then it sets *pOutFlags to -** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. -** -** SQLite will also add one of the following flags to the xOpen() -** call, depending on the object being opened: -** -**
    -**
  • [SQLITE_OPEN_MAIN_DB] -**
  • [SQLITE_OPEN_MAIN_JOURNAL] -**
  • [SQLITE_OPEN_TEMP_DB] -**
  • [SQLITE_OPEN_TEMP_JOURNAL] -**
  • [SQLITE_OPEN_TRANSIENT_DB] -**
  • [SQLITE_OPEN_SUBJOURNAL] -**
  • [SQLITE_OPEN_MASTER_JOURNAL] -**
-** -** The file I/O implementation can use the object type flags to -** change the way it deals with files. For example, an application -** that does not care about crash recovery or rollback might make -** the open of a journal file a no-op. Writes to this journal would -** also be no-ops, and any attempt to read the journal would return -** SQLITE_IOERR. Or the implementation might recognize that a database -** file will be doing page-aligned sector reads and writes in a random -** order and set up its I/O subsystem accordingly. -** -** SQLite might also add one of the following flags to the xOpen method: -** -**
    -**
  • [SQLITE_OPEN_DELETEONCLOSE] -**
  • [SQLITE_OPEN_EXCLUSIVE] -**
-** -** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be -** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE] -** will be set for TEMP databases, journals and for subjournals. -** -** The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction -** with the [SQLITE_OPEN_CREATE] flag, which are both directly -** analogous to the O_EXCL and O_CREAT flags of the POSIX open() -** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the -** SQLITE_OPEN_CREATE, is used to indicate that file should always -** be created, and that it is an error if it already exists. -** It is not used to indicate the file should be opened -** for exclusive access. -** -** At least szOsFile bytes of memory are allocated by SQLite -** to hold the [sqlite3_file] structure passed as the third -** argument to xOpen. The xOpen method does not have to -** allocate the structure; it should just fill it in. Note that -** the xOpen method must set the sqlite3_file.pMethods to either -** a valid [sqlite3_io_methods] object or to NULL. xOpen must do -** this even if the open fails. SQLite expects that the sqlite3_file.pMethods -** element will be valid after xOpen returns regardless of the success -** or failure of the xOpen call. -** -** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] -** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to -** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] -** to test whether a file is at least readable. The file can be a -** directory. -** -** SQLite will always allocate at least mxPathname+1 bytes for the -** output buffer xFullPathname. The exact size of the output buffer -** is also passed as a parameter to both methods. If the output buffer -** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is -** handled as a fatal error by SQLite, vfs implementations should endeavor -** to prevent this by setting mxPathname to a sufficiently large value. -** -** The xRandomness(), xSleep(), and xCurrentTime() interfaces -** are not strictly a part of the filesystem, but they are -** included in the VFS structure for completeness. -** The xRandomness() function attempts to return nBytes bytes -** of good-quality randomness into zOut. The return value is -** the actual number of bytes of randomness obtained. -** The xSleep() method causes the calling thread to sleep for at -** least the number of microseconds given. The xCurrentTime() -** method returns a Julian Day Number for the current date and time. -** -*/ -typedef struct sqlite3_vfs sqlite3_vfs; -struct sqlite3_vfs { - int iVersion; /* Structure version number */ - int szOsFile; /* Size of subclassed sqlite3_file */ - int mxPathname; /* Maximum file pathname length */ - sqlite3_vfs *pNext; /* Next registered VFS */ - const char *zName; /* Name of this virtual file system */ - void *pAppData; /* Pointer to application-specific data */ - int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, - int flags, int *pOutFlags); - int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); - int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); - int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); - void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); - void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); - void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); - void (*xDlClose)(sqlite3_vfs*, void*); - int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); - int (*xSleep)(sqlite3_vfs*, int microseconds); - int (*xCurrentTime)(sqlite3_vfs*, double*); - int (*xGetLastError)(sqlite3_vfs*, int, char *); - /* New fields may be appended in figure versions. The iVersion - ** value will increment whenever this happens. */ -}; - -/* -** CAPI3REF: Flags for the xAccess VFS method -** -** These integer constants can be used as the third parameter to -** the xAccess method of an [sqlite3_vfs] object. They determine -** what kind of permissions the xAccess method is looking for. -** With SQLITE_ACCESS_EXISTS, the xAccess method -** simply checks whether the file exists. -** With SQLITE_ACCESS_READWRITE, the xAccess method -** checks whether the file is both readable and writable. -** With SQLITE_ACCESS_READ, the xAccess method -** checks whether the file is readable. -*/ -#define SQLITE_ACCESS_EXISTS 0 -#define SQLITE_ACCESS_READWRITE 1 -#define SQLITE_ACCESS_READ 2 - -/* -** CAPI3REF: Initialize The SQLite Library -** -** ^The sqlite3_initialize() routine initializes the -** SQLite library. ^The sqlite3_shutdown() routine -** deallocates any resources that were allocated by sqlite3_initialize(). -** These routines are designed to aid in process initialization and -** shutdown on embedded systems. Workstation applications using -** SQLite normally do not need to invoke either of these routines. -** -** A call to sqlite3_initialize() is an "effective" call if it is -** the first time sqlite3_initialize() is invoked during the lifetime of -** the process, or if it is the first time sqlite3_initialize() is invoked -** following a call to sqlite3_shutdown(). ^(Only an effective call -** of sqlite3_initialize() does any initialization. All other calls -** are harmless no-ops.)^ -** -** A call to sqlite3_shutdown() is an "effective" call if it is the first -** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only -** an effective call to sqlite3_shutdown() does any deinitialization. -** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ -** -** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() -** is not. The sqlite3_shutdown() interface must only be called from a -** single thread. All open [database connections] must be closed and all -** other SQLite resources must be deallocated prior to invoking -** sqlite3_shutdown(). -** -** Among other things, ^sqlite3_initialize() will invoke -** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() -** will invoke sqlite3_os_end(). -** -** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. -** ^If for some reason, sqlite3_initialize() is unable to initialize -** the library (perhaps it is unable to allocate a needed resource such -** as a mutex) it returns an [error code] other than [SQLITE_OK]. -** -** ^The sqlite3_initialize() routine is called internally by many other -** SQLite interfaces so that an application usually does not need to -** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] -** calls sqlite3_initialize() so the SQLite library will be automatically -** initialized when [sqlite3_open()] is called if it has not be initialized -** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] -** compile-time option, then the automatic calls to sqlite3_initialize() -** are omitted and the application must call sqlite3_initialize() directly -** prior to using any other SQLite interface. For maximum portability, -** it is recommended that applications always invoke sqlite3_initialize() -** directly prior to using any other SQLite interface. Future releases -** of SQLite may require this. In other words, the behavior exhibited -** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the -** default behavior in some future release of SQLite. -** -** The sqlite3_os_init() routine does operating-system specific -** initialization of the SQLite library. The sqlite3_os_end() -** routine undoes the effect of sqlite3_os_init(). Typical tasks -** performed by these routines include allocation or deallocation -** of static resources, initialization of global variables, -** setting up a default [sqlite3_vfs] module, or setting up -** a default configuration using [sqlite3_config()]. -** -** The application should never invoke either sqlite3_os_init() -** or sqlite3_os_end() directly. The application should only invoke -** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() -** interface is called automatically by sqlite3_initialize() and -** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate -** implementations for sqlite3_os_init() and sqlite3_os_end() -** are built into SQLite when it is compiled for Unix, Windows, or OS/2. -** When [custom builds | built for other platforms] -** (using the [SQLITE_OS_OTHER=1] compile-time -** option) the application must supply a suitable implementation for -** sqlite3_os_init() and sqlite3_os_end(). An application-supplied -** implementation of sqlite3_os_init() or sqlite3_os_end() -** must return [SQLITE_OK] on success and some other [error code] upon -** failure. -*/ -SQLITE_API int sqlite3_initialize(void); -SQLITE_API int sqlite3_shutdown(void); -SQLITE_API int sqlite3_os_init(void); -SQLITE_API int sqlite3_os_end(void); - -/* -** CAPI3REF: Configuring The SQLite Library -** -** The sqlite3_config() interface is used to make global configuration -** changes to SQLite in order to tune SQLite to the specific needs of -** the application. The default configuration is recommended for most -** applications and so this routine is usually not necessary. It is -** provided to support rare applications with unusual needs. -** -** The sqlite3_config() interface is not threadsafe. The application -** must insure that no other SQLite interfaces are invoked by other -** threads while sqlite3_config() is running. Furthermore, sqlite3_config() -** may only be invoked prior to library initialization using -** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. -** ^If sqlite3_config() is called after [sqlite3_initialize()] and before -** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. -** Note, however, that ^sqlite3_config() can be called as part of the -** implementation of an application-defined [sqlite3_os_init()]. -** -** The first argument to sqlite3_config() is an integer -** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines -** what property of SQLite is to be configured. Subsequent arguments -** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option] -** in the first argument. -** -** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. -** ^If the option is unknown or SQLite is unable to set the option -** then this routine returns a non-zero [error code]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_config(int, ...); - -/* -** CAPI3REF: Configure database connections -** EXPERIMENTAL -** -** The sqlite3_db_config() interface is used to make configuration -** changes to a [database connection]. The interface is similar to -** [sqlite3_config()] except that the changes apply to a single -** [database connection] (specified in the first argument). The -** sqlite3_db_config() interface should only be used immediately after -** the database connection is created using [sqlite3_open()], -** [sqlite3_open16()], or [sqlite3_open_v2()]. -** -** The second argument to sqlite3_db_config(D,V,...) is the -** configuration verb - an integer code that indicates what -** aspect of the [database connection] is being configured. -** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE]. -** New verbs are likely to be added in future releases of SQLite. -** Additional arguments depend on the verb. -** -** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if -** the call is considered successful. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...); - -/* -** CAPI3REF: Memory Allocation Routines -** EXPERIMENTAL -** -** An instance of this object defines the interface between SQLite -** and low-level memory allocation routines. -** -** This object is used in only one place in the SQLite interface. -** A pointer to an instance of this object is the argument to -** [sqlite3_config()] when the configuration option is -** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. -** By creating an instance of this object -** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) -** 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 several [built-in memory allocators] -** that are perfectly adequate for the overwhelming majority of applications -** and that this object is only useful to a tiny minority of applications -** with specialized memory allocation requirements. This object is -** also used during testing of SQLite in order to specify an alternative -** memory allocator that simulates memory out-of-memory conditions in -** order to verify that SQLite recovers gracefully from such -** conditions. -** -** The xMalloc and xFree methods must work like the -** 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 guarantees 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 -** previously obtained from xMalloc or xRealloc. The allocated size -** is always at least as big as the requested size but may be larger. -** -** The xRoundup method returns what would be the allocated size of -** a memory allocation given a particular requested size. Most memory -** 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. -** 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, -** it might allocate any require mutexes or initialize internal data -** structures. The xShutdown method is invoked (indirectly) by -** [sqlite3_shutdown()] and should deallocate any resources acquired -** by xInit. The pAppData pointer is used as the only parameter to -** 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; -struct sqlite3_mem_methods { - void *(*xMalloc)(int); /* Memory allocation function */ - void (*xFree)(void*); /* Free a prior allocation */ - void *(*xRealloc)(void*,int); /* Resize an allocation */ - int (*xSize)(void*); /* Return the size of an allocation */ - int (*xRoundup)(int); /* Round up request size to allocation size */ - int (*xInit)(void*); /* Initialize the memory allocator */ - void (*xShutdown)(void*); /* Deinitialize the memory allocator */ - void *pAppData; /* Argument to xInit() and xShutdown() */ -}; - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** These constants are the available integer configuration options that -** can be passed as the first argument to the [sqlite3_config()] interface. -** -** New configuration options may be added in future releases of SQLite. -** Existing configuration options might be discontinued. Applications -** should check the return code from [sqlite3_config()] to make sure that -** the call worked. The [sqlite3_config()] interface will return a -** non-zero [error code] if a discontinued or unsupported configuration option -** is invoked. -** -**
-**
SQLITE_CONFIG_SINGLETHREAD
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Single-thread. In other words, it disables -** all mutexing and puts SQLite into a mode where it can only be used -** by a single thread. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to change the [threading mode] from its default -** value of Single-thread and so [sqlite3_config()] will return -** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD -** configuration option.
-** -**
SQLITE_CONFIG_MULTITHREAD
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Multi-thread. In other words, it disables -** mutexing on [database connection] and [prepared statement] objects. -** The application is responsible for serializing access to -** [database connections] and [prepared statements]. But other mutexes -** are enabled so that SQLite will be safe to use in a multi-threaded -** environment as long as no two threads attempt to use the same -** [database connection] at the same time. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to set the Multi-thread [threading mode] and -** [sqlite3_config()] will return [SQLITE_ERROR] if called with the -** SQLITE_CONFIG_MULTITHREAD configuration option.
-** -**
SQLITE_CONFIG_SERIALIZED
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Serialized. In other words, this option enables -** all mutexes including the recursive -** mutexes on [database connection] and [prepared statement] objects. -** In this mode (which is the default when SQLite is compiled with -** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access -** to [database connections] and [prepared statements] so that the -** application is free to use the same [database connection] or the -** same [prepared statement] in different threads at the same time. -** ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to set the Serialized [threading mode] and -** [sqlite3_config()] will return [SQLITE_ERROR] if called with the -** SQLITE_CONFIG_SERIALIZED configuration option.
-** -**
SQLITE_CONFIG_MALLOC
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mem_methods] structure. The argument specifies -** alternative low-level memory allocation routines to be used in place of -** the memory allocation routines built into SQLite.)^ ^SQLite makes -** its own private copy of the content of the [sqlite3_mem_methods] structure -** before the [sqlite3_config()] call returns.
-** -**
SQLITE_CONFIG_GETMALLOC
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods] -** structure is filled with the currently defined memory allocation routines.)^ -** This option can be used to overload the default memory allocation -** routines with a wrapper that simulations memory allocation failure or -** tracks memory usage, for example.
-** -**
SQLITE_CONFIG_MEMSTATUS
-**
^This option takes single argument of type int, interpreted as a -** boolean, which enables or disables the collection of memory allocation -** statistics. ^(When memory allocation statistics are disabled, the -** following SQLite interfaces become non-operational: -**
    -**
  • [sqlite3_memory_used()] -**
  • [sqlite3_memory_highwater()] -**
  • [sqlite3_soft_heap_limit()] -**
  • [sqlite3_status()] -**
)^ -** ^Memory allocation statistics are enabled by default unless SQLite is -** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory -** allocation statistics are disabled by default. -**
-** -**
SQLITE_CONFIG_SCRATCH
-**
^This option specifies a static memory buffer that SQLite can use for -** scratch memory. There are three arguments: A pointer an 8-byte -** aligned memory buffer from which the scrach allocations will be -** drawn, the size of each scratch allocation (sz), -** and the maximum number of scratch allocations (N). The sz -** argument must be a multiple of 16. The sz parameter should be a few bytes -** larger than the actual scratch space required due to internal overhead. -** The first argument must be a pointer to an 8-byte aligned buffer -** of at least sz*N bytes of memory. -** ^SQLite will use no more than one scratch buffer per thread. So -** N should be set to the expected maximum number of threads. ^SQLite will -** never require a scratch buffer that is more than 6 times the database -** page size. ^If SQLite needs needs additional scratch memory beyond -** what is provided by this configuration option, then -** [sqlite3_malloc()] will be used to obtain the memory needed.
-** -**
SQLITE_CONFIG_PAGECACHE
-**
^This option specifies a static memory buffer that SQLite can use for -** the database page cache with the default page cache implemenation. -** This configuration should not be used if an application-define page -** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option. -** There are three arguments to this option: A pointer to 8-byte aligned -** memory, the size of each page buffer (sz), and the number of pages (N). -** The sz argument should be the size of the largest database page -** (a power of two between 512 and 32768) plus a little extra for each -** page header. ^The page header size is 20 to 40 bytes depending on -** the host architecture. ^It is harmless, apart from the wasted memory, -** to make sz a little too large. The first -** argument should point to an allocation of at least sz*N bytes of memory. -** ^SQLite will use the memory provided by the first argument to satisfy its -** memory needs for the first N pages that it adds to cache. ^If additional -** page cache memory is needed beyond what is provided by this option, then -** SQLite goes to [sqlite3_malloc()] for the additional storage space. -** ^The implementation might use one or more of the N buffers to hold -** memory accounting information. The pointer in the first argument must -** be aligned to an 8-byte boundary or subsequent behavior of SQLite -** will be undefined.
-** -**
SQLITE_CONFIG_HEAP
-**
^This option specifies a static memory buffer that SQLite will use -** for all of its dynamic memory allocation needs beyond those provided -** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. -** There are three arguments: An 8-byte aligned pointer to the memory, -** the number of bytes in the memory buffer, and the minimum allocation size. -** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts -** to using its default memory allocator (the system malloc() implementation), -** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the -** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or -** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory -** allocator is engaged to handle all of SQLites memory allocation needs. -** The first pointer (the memory pointer) must be aligned to an 8-byte -** boundary or subsequent behavior of SQLite will be undefined.
-** -**
SQLITE_CONFIG_MUTEX
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mutex_methods] structure. The argument specifies -** alternative low-level mutex routines to be used in place -** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the -** content of the [sqlite3_mutex_methods] structure before the call to -** [sqlite3_config()] returns. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** the entire mutexing subsystem is omitted from the build and hence calls to -** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will -** return [SQLITE_ERROR].
-** -**
SQLITE_CONFIG_GETMUTEX
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mutex_methods] structure. The -** [sqlite3_mutex_methods] -** structure is filled with the currently defined mutex routines.)^ -** This option can be used to overload the default mutex allocation -** routines with a wrapper used to track mutex usage for performance -** profiling or testing, for example. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** the entire mutexing subsystem is omitted from the build and hence calls to -** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will -** return [SQLITE_ERROR].
-** -**
SQLITE_CONFIG_LOOKASIDE
-**
^(This option takes two arguments that determine the default -** memory allocation for the lookaside memory allocator on each -** [database connection]. The first argument is the -** size of each lookaside buffer slot and the second is the number of -** slots allocated to each database connection.)^ ^(This option sets the -** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] -** verb to [sqlite3_db_config()] can be used to change the lookaside -** configuration on individual connections.)^
-** -**
SQLITE_CONFIG_PCACHE
-**
^(This option takes a single argument which is a pointer to -** an [sqlite3_pcache_methods] object. This object specifies the interface -** to a custom page cache implementation.)^ ^SQLite makes a copy of the -** object and uses it for page cache memory allocations.
-** -**
SQLITE_CONFIG_GETPCACHE
-**
^(This option takes a single argument which is a pointer to an -** [sqlite3_pcache_methods] object. SQLite copies of the current -** page cache implementation into that object.)^
-** -**
-*/ -#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ -#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ -#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ -#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ -#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ -#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ -#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ -#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ -#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ -#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ -#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ -/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ -#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ -#define SQLITE_CONFIG_PCACHE 14 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_GETPCACHE 15 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** These constants are the available integer configuration options that -** can be passed as the second argument to the [sqlite3_db_config()] interface. -** -** New configuration options may be added in future releases of SQLite. -** Existing configuration options might be discontinued. Applications -** should check the return code from [sqlite3_db_config()] to make sure that -** the call worked. ^The [sqlite3_db_config()] interface will return a -** non-zero [error code] if a discontinued or unsupported configuration option -** is invoked. -** -**
-**
SQLITE_DBCONFIG_LOOKASIDE
-**
^This option takes three additional arguments that determine the -** [lookaside memory allocator] configuration for the [database connection]. -** ^The first argument (the third parameter to [sqlite3_db_config()] is a -** pointer to an memory buffer to use for lookaside memory. -** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb -** may be NULL in which case SQLite will allocate the -** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the -** size of each lookaside buffer slot. ^The third argument is the number of -** 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. The buffer -** must be aligned to an 8-byte boundary. ^If the second argument to -** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally -** rounded down to the next smaller -** multiple of 8. See also: [SQLITE_CONFIG_LOOKASIDE]
-** -**
-*/ -#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ - - -/* -** CAPI3REF: Enable Or Disable Extended Result Codes -** -** ^The sqlite3_extended_result_codes() routine enables or disables the -** [extended result codes] feature of SQLite. ^The extended result -** codes are disabled by default for historical compatibility. -*/ -SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); - -/* -** CAPI3REF: Last Insert Rowid -** -** ^Each entry in an SQLite table has a unique 64-bit signed -** integer key called the [ROWID | "rowid"]. ^The rowid is always available -** as an undeclared column named ROWID, OID, or _ROWID_ as long as those -** names are not also used by explicitly declared columns. ^If -** the table has a column of type [INTEGER PRIMARY KEY] then that column -** is another alias for the rowid. -** -** ^This routine returns the [rowid] of the most recent -** successful [INSERT] into the database from the [database connection] -** in the first argument. ^If no successful [INSERT]s -** have ever occurred on that database connection, zero is returned. -** -** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted -** row is returned by this routine as long as the trigger is running. -** But once the trigger terminates, the value returned by this routine -** reverts to the last value inserted before the trigger fired.)^ -** -** ^An [INSERT] that fails due to a constraint violation is not a -** successful [INSERT] and does not change the value returned by this -** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, -** and INSERT OR ABORT make no changes to the return value of this -** routine when their insertion fails. ^(When INSERT OR REPLACE -** encounters a constraint violation, it does not fail. The -** INSERT continues to completion after deleting rows that caused -** the constraint problem so INSERT OR REPLACE will always change -** the return value of this interface.)^ -** -** ^For the purposes of this routine, an [INSERT] is considered to -** be successful even if it is subsequently rolled back. -** -** This function is accessible to SQL statements via the -** [last_insert_rowid() SQL function]. -** -** If a separate thread performs a new [INSERT] on the same -** database connection while the [sqlite3_last_insert_rowid()] -** function is running and thus changes the last insert [rowid], -** then the value returned by [sqlite3_last_insert_rowid()] is -** unpredictable and might not equal either the old or the new -** last insert [rowid]. -*/ -SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); - -/* -** CAPI3REF: Count The Number Of Rows Modified -** -** ^This function returns the number of database rows that were changed -** or inserted or deleted by the most recently completed SQL statement -** on the [database connection] specified by the first parameter. -** ^(Only changes that are directly specified by the [INSERT], [UPDATE], -** or [DELETE] statement are counted. Auxiliary changes caused by -** triggers or [foreign key actions] are not counted.)^ Use the -** [sqlite3_total_changes()] function to find the total number of changes -** including changes caused by triggers and foreign key actions. -** -** ^Changes to a view that are simulated by an [INSTEAD OF trigger] -** are not counted. Only real table changes are counted. -** -** ^(A "row change" is a change to a single row of a single table -** caused by an INSERT, DELETE, or UPDATE statement. Rows that -** are changed as side effects of [REPLACE] constraint resolution, -** rollback, ABORT processing, [DROP TABLE], or by any other -** mechanisms do not count as direct row changes.)^ -** -** A "trigger context" is a scope of execution that begins and -** ends with the script of a [CREATE TRIGGER | trigger]. -** Most SQL statements are -** evaluated outside of any trigger. This is the "top level" -** trigger context. If a trigger fires from the top level, a -** new trigger context is entered for the duration of that one -** trigger. Subtriggers create subcontexts for their duration. -** -** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does -** not create a new trigger context. -** -** ^This function returns the number of direct row changes in the -** most recent INSERT, UPDATE, or DELETE statement within the same -** trigger context. -** -** ^Thus, when called from the top level, this function returns the -** number of changes in the most recent INSERT, UPDATE, or DELETE -** that also occurred at the top level. ^(Within the body of a trigger, -** the sqlite3_changes() interface can be called to find the number of -** changes in the most recently completed INSERT, UPDATE, or DELETE -** statement within the body of the same trigger. -** However, the number returned does not include changes -** caused by subtriggers since those have their own context.)^ -** -** 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. -*/ -SQLITE_API int sqlite3_changes(sqlite3*); - -/* -** CAPI3REF: Total Number Of Rows Modified -** -** ^This function returns the number of row changes caused by [INSERT], -** [UPDATE] or [DELETE] statements since the [database connection] was opened. -** ^(The count returned by sqlite3_total_changes() includes all changes -** from all [CREATE TRIGGER | trigger] contexts and changes made by -** [foreign key actions]. However, -** the count does not include changes used to implement [REPLACE] constraints, -** do rollbacks or ABORT processing, or [DROP TABLE] processing. The -** count does not include rows of views that fire an [INSTEAD OF trigger], -** though if the INSTEAD OF trigger makes changes of its own, those changes -** are counted.)^ -** ^The sqlite3_total_changes() function counts the changes as soon as -** the statement that makes them is completed (when the statement handle -** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). -** -** See also the [sqlite3_changes()] interface, the -** [count_changes pragma], and the [total_changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_total_changes(sqlite3*); - -/* -** CAPI3REF: Interrupt A Long-Running Query -** -** ^This function causes any pending database operation to abort and -** return at its earliest opportunity. This routine is typically -** called in response to a user action such as pressing "Cancel" -** or Ctrl-C where the user wants a long query operation to halt -** immediately. -** -** ^It is safe to call this routine from a thread different from the -** thread that is currently running the database operation. But it -** is not safe to call this routine with a [database connection] that -** is closed or might close before sqlite3_interrupt() returns. -** -** ^If an SQL operation is very nearly finished at the time when -** sqlite3_interrupt() is called, then it might not have an opportunity -** to be interrupted and might continue to completion. -** -** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. -** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE -** that is inside an explicit transaction, then the entire transaction -** will be rolled back automatically. -** -** ^The sqlite3_interrupt(D) call is in effect until all currently running -** SQL statements on [database connection] D complete. ^Any new SQL statements -** that are started after the sqlite3_interrupt() call and before the -** running statements reaches zero are interrupted as if they had been -** running prior to the sqlite3_interrupt() call. ^New SQL statements -** that are started after the running statement count reaches zero are -** not effected by the sqlite3_interrupt(). -** ^A call to sqlite3_interrupt(D) that occurs when there are no running -** SQL statements is a no-op and has no effect on SQL statements -** that are started after the sqlite3_interrupt() call returns. -** -** If the database connection closes while [sqlite3_interrupt()] -** is running then bad things will likely happen. -*/ -SQLITE_API void sqlite3_interrupt(sqlite3*); - -/* -** CAPI3REF: Determine If An SQL Statement Is Complete -** -** These routines are useful during command-line input to determine if the -** currently entered text seems to form a complete SQL statement or -** if additional input is needed before sending the text into -** SQLite for parsing. ^These routines return 1 if the input string -** appears to be a complete SQL statement. ^A statement is judged to be -** complete if it ends with a semicolon token and is not a prefix of a -** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within -** string literals or quoted identifier names or comments are not -** independent tokens (they are part of the token in which they are -** embedded) and thus do not count as a statement terminator. ^Whitespace -** and comments that follow the final semicolon are ignored. -** -** ^These routines return 0 if the statement is incomplete. ^If a -** memory allocation fails, then SQLITE_NOMEM is returned. -** -** ^These routines do not parse the SQL statements thus -** will not detect syntactically incorrect SQL. -** -** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior -** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked -** automatically by sqlite3_complete16(). If that initialization fails, -** then the return value from sqlite3_complete16() will be non-zero -** regardless of whether or not the input SQL is complete.)^ -** -** The input to [sqlite3_complete()] must be a zero-terminated -** UTF-8 string. -** -** The input to [sqlite3_complete16()] must be a zero-terminated -** UTF-16 string in native byte order. -*/ -SQLITE_API int sqlite3_complete(const char *sql); -SQLITE_API int sqlite3_complete16(const void *sql); - -/* -** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors -** -** ^This routine sets a callback function that might be invoked whenever -** an attempt is made to open a database table that another thread -** or process has locked. -** -** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] -** is returned immediately upon encountering the lock. ^If the busy callback -** is not NULL, then the callback might be invoked with two arguments. -** -** ^The first argument to the busy handler is a copy of the void* pointer which -** is the third argument to sqlite3_busy_handler(). ^The second argument to -** the busy handler callback is the number of times that the busy handler has -** been invoked for this locking event. ^If the -** busy callback returns 0, then no additional attempts are made to -** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. -** ^If the callback returns non-zero, then another attempt -** is made to open the database for reading and the cycle repeats. -** -** The presence of a busy handler does not guarantee that it will be invoked -** when there is lock contention. ^If SQLite determines that invoking the busy -** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] -** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler. -** Consider a scenario where one process is holding a read lock that -** it is trying to promote to a reserved lock and -** a second process is holding a reserved lock that it is trying -** to promote to an exclusive lock. The first process cannot proceed -** because it is blocked by the second and the second process cannot -** proceed because it is blocked by the first. If both processes -** invoke the busy handlers, neither will make any progress. Therefore, -** SQLite returns [SQLITE_BUSY] for the first process, hoping that this -** will induce the first process to release its read lock and allow -** the second process to proceed. -** -** ^The default busy callback is NULL. -** -** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] -** when SQLite is in the middle of a large transaction where all the -** changes will not fit into the in-memory cache. SQLite will -** already hold a RESERVED lock on the database file, but it needs -** to promote this lock to EXCLUSIVE so that it can spill cache -** pages into the database file without harm to concurrent -** readers. ^If it is unable to promote the lock, then the in-memory -** cache will be left in an inconsistent state and so the error -** code is promoted from the relatively benign [SQLITE_BUSY] to -** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion -** forces an automatic rollback of the changes. See the -** -** CorruptionFollowingBusyError wiki page for a discussion of why -** this is important. -** -** ^(There can only be a single busy handler defined for each -** [database connection]. Setting a new busy handler clears any -** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] -** will also set or clear the busy handler. -** -** The busy callback should not take any actions which modify the -** database connection that invoked the busy handler. Any such actions -** result in undefined behavior. -** -** A busy handler must not close the database connection -** or [prepared statement] that invoked the busy handler. -*/ -SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); - -/* -** CAPI3REF: Set A Busy Timeout -** -** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps -** for a specified amount of time when a table is locked. ^The handler -** will sleep multiple times until at least "ms" milliseconds of sleeping -** have accumulated. ^After at least "ms" milliseconds of sleeping, -** the handler returns 0 which causes [sqlite3_step()] to return -** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. -** -** ^Calling this routine with an argument less than or equal to zero -** turns off all busy handlers. -** -** ^(There can only be a single busy handler for a particular -** [database connection] any any given moment. If another busy handler -** was defined (using [sqlite3_busy_handler()]) prior to calling -** this routine, that other busy handler is cleared.)^ -*/ -SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); - -/* -** CAPI3REF: Convenience Routines For Running Queries -** -** Definition: A result table is memory data structure created by the -** [sqlite3_get_table()] interface. A result table records the -** complete query results from one or more queries. -** -** The table conceptually has a number of rows and columns. But -** these numbers are not part of the result table itself. These -** numbers are obtained separately. Let N be the number of rows -** and M be the number of columns. -** -** A result table is an array of pointers to zero-terminated UTF-8 strings. -** There are (N+1)*M elements in the array. The first M pointers point -** to zero-terminated strings that contain the names of the columns. -** The remaining entries all point to query results. NULL values result -** in NULL pointers. All other values are in their UTF-8 zero-terminated -** string representation as returned by [sqlite3_column_text()]. -** -** A result table might consist of one or more memory allocations. -** It is not safe to pass a result table directly to [sqlite3_free()]. -** A result table should be deallocated using [sqlite3_free_table()]. -** -** As an example of the result table format, suppose a query result -** is as follows: -** -** 
-**        Name        | Age
-**        -----------------------
-**        Alice       | 43
-**        Bob         | 28
-**        Cindy       | 21
-**
-** -** There are two column (M==2) and three rows (N==3). Thus the -** result table has 8 entries. Suppose the result table is stored -** in an array names azResult. Then azResult holds this content: -** -** 
-**        azResult[0] = "Name";
-**        azResult[1] = "Age";
-**        azResult[2] = "Alice";
-**        azResult[3] = "43";
-**        azResult[4] = "Bob";
-**        azResult[5] = "28";
-**        azResult[6] = "Cindy";
-**        azResult[7] = "21";
-**
-** -** ^The sqlite3_get_table() function evaluates one or more -** semicolon-separated SQL statements in the zero-terminated UTF-8 -** string of its 2nd parameter and returns a result table to the -** pointer given in its 3rd parameter. -** -** After the application has finished with the result from sqlite3_get_table(), -** it should pass the result table pointer to sqlite3_free_table() in order to -** release the memory that was malloced. Because of the way the -** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling -** function must not try to call [sqlite3_free()] directly. Only -** [sqlite3_free_table()] is able to release the memory properly and safely. -** -** ^(The sqlite3_get_table() interface is implemented as a wrapper around -** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access -** to any internal data structures of SQLite. It uses only the public -** interface defined here. As a consequence, errors that occur in the -** wrapper layer outside of the internal [sqlite3_exec()] call are not -** reflected in subsequent calls to [sqlite3_errcode()] or -** [sqlite3_errmsg()].)^ -*/ -SQLITE_API int sqlite3_get_table( - sqlite3 *db, /* An open database */ - const char *zSql, /* SQL to be evaluated */ - char ***pazResult, /* Results of the query */ - int *pnRow, /* Number of result rows written here */ - int *pnColumn, /* Number of result columns written here */ - char **pzErrmsg /* Error msg written here */ -); -SQLITE_API void sqlite3_free_table(char **result); - -/* -** CAPI3REF: Formatted String Printing Functions -** -** These routines are work-alikes of the "printf()" family of functions -** from the standard C library. -** -** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their -** results into memory obtained from [sqlite3_malloc()]. -** The strings returned by these two routines should be -** released by [sqlite3_free()]. ^Both routines return a -** NULL pointer if [sqlite3_malloc()] is unable to allocate enough -** memory to hold the resulting string. -** -** ^(In sqlite3_snprintf() routine is similar to "snprintf()" from -** the standard C library. The result is written into the -** buffer supplied as the second parameter whose size is given by -** the first parameter. Note that the order of the -** first two parameters is reversed from snprintf().)^ This is an -** historical accident that cannot be fixed without breaking -** backwards compatibility. ^(Note also that sqlite3_snprintf() -** returns a pointer to its buffer instead of the number of -** characters actually written into the buffer.)^ We admit that -** the number of characters written would be a more useful return -** value but we cannot change the implementation of sqlite3_snprintf() -** now without breaking compatibility. -** -** ^As long as the buffer size is greater than zero, sqlite3_snprintf() -** guarantees that the buffer is always zero-terminated. ^The first -** parameter "n" is the total size of the buffer, including space for -** the zero terminator. So the longest string that can be completely -** written will be n-1 characters. -** -** These routines all implement some additional formatting -** options that are useful for constructing SQL statements. -** All of the usual printf() formatting options apply. In addition, there -** is are "%q", "%Q", and "%z" options. -** -** ^(The %q option works like %s in that it substitutes a null-terminated -** string from the argument list. But %q also doubles every '\'' character. -** %q is designed for use inside a string literal.)^ By doubling each '\'' -** character it escapes that character and allows it to be inserted into -** the string. -** -** For example, assume the string variable zText contains text as follows: -** -** 
-**  char *zText = "It's a happy day!";
-**
-** -** One can use this text in an SQL statement as follows: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** Because the %q format string is used, the '\'' character in zText -** is escaped and the SQL generated is as follows: -** -** 
-**  INSERT INTO table1 VALUES('It''s a happy day!')
-**
-** -** This is correct. Had we used %s instead of %q, the generated SQL -** would have looked like this: -** -** 
-**  INSERT INTO table1 VALUES('It's a happy day!');
-**
-** -** This second example is an SQL syntax error. As a general rule you should -** always use %q instead of %s when inserting text into a string literal. -** -** ^(The %Q option works like %q except it also adds single quotes around -** the outside of the total string. Additionally, if the parameter in the -** argument list is a NULL pointer, %Q substitutes the text "NULL" (without -** single quotes).)^ So, for example, one could say: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** The code above will render a correct SQL statement in the zSQL -** variable even if the zText variable is a NULL pointer. -** -** ^(The "%z" formatting option works like "%s" but with the -** addition that after the string has been read and copied into -** the result, [sqlite3_free()] is called on the input string.)^ -*/ -SQLITE_API char *sqlite3_mprintf(const char*,...); -SQLITE_API char *sqlite3_vmprintf(const char*, va_list); -SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); - -/* -** CAPI3REF: Memory Allocation Subsystem -** -** The SQLite core uses these three routines for all of its own -** internal memory allocation needs. "Core" in the previous sentence -** does not include operating-system specific VFS implementation. The -** Windows VFS uses native malloc() and free() for some operations. -** -** ^The sqlite3_malloc() routine returns a pointer to a block -** of memory at least N bytes in length, where N is the parameter. -** ^If sqlite3_malloc() is unable to obtain sufficient free -** memory, it returns a NULL pointer. ^If the parameter N to -** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns -** a NULL pointer. -** -** ^Calling sqlite3_free() with a pointer previously returned -** by sqlite3_malloc() or sqlite3_realloc() releases that memory so -** that it might be reused. ^The sqlite3_free() routine is -** a no-op if is called with a NULL pointer. Passing a NULL pointer -** to sqlite3_free() is harmless. After being freed, memory -** should neither be read nor written. Even reading previously freed -** memory might result in a segmentation fault or other severe error. -** Memory corruption, a segmentation fault, or other severe error -** might result if sqlite3_free() is called with a non-NULL pointer that -** was not obtained from sqlite3_malloc() or sqlite3_realloc(). -** -** ^(The sqlite3_realloc() interface attempts to resize a -** prior memory allocation to be at least N bytes, where N is the -** second parameter. The memory allocation to be resized is the first -** parameter.)^ ^ If the first parameter to sqlite3_realloc() -** is a NULL pointer then its behavior is identical to calling -** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). -** ^If the second parameter to sqlite3_realloc() is zero or -** negative then the behavior is exactly the same as calling -** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). -** ^sqlite3_realloc() returns a pointer to a memory allocation -** of at least N bytes in size or NULL if sufficient memory is unavailable. -** ^If M is the size of the prior allocation, then min(N,M) bytes -** of the prior allocation are copied into the beginning of buffer returned -** by sqlite3_realloc() and the prior allocation is freed. -** ^If sqlite3_realloc() returns NULL, then the prior allocation -** is not freed. -** -** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() -** is always aligned to at least an 8 byte boundary. -** -** In SQLite version 3.5.0 and 3.5.1, it was possible to define -** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in -** implementation of these routines to be omitted. That capability -** is no longer provided. Only built-in memory allocators can be used. -** -** The Windows OS interface layer calls -** the system malloc() and free() directly when converting -** filenames between the UTF-8 encoding used by SQLite -** and whatever filename encoding is used by the particular Windows -** installation. Memory allocation errors are detected, but -** they are reported back as [SQLITE_CANTOPEN] or -** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. -** -** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] -** must be either NULL or else pointers obtained from a prior -** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have -** not yet been released. -** -** The application must not read or write any part of -** a block of memory after it has been released using -** [sqlite3_free()] or [sqlite3_realloc()]. -*/ -SQLITE_API void *sqlite3_malloc(int); -SQLITE_API void *sqlite3_realloc(void*, int); -SQLITE_API void sqlite3_free(void*); - -/* -** CAPI3REF: Memory Allocator Statistics -** -** SQLite provides these two interfaces for reporting on the status -** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] -** routines, which form the built-in memory allocation subsystem. -** -** ^The [sqlite3_memory_used()] routine returns the number of bytes -** of memory currently outstanding (malloced but not freed). -** ^The [sqlite3_memory_highwater()] routine returns the maximum -** value of [sqlite3_memory_used()] since the high-water mark -** was last reset. ^The values returned by [sqlite3_memory_used()] and -** [sqlite3_memory_highwater()] include any overhead -** added by SQLite in its implementation of [sqlite3_malloc()], -** but not overhead added by the any underlying system library -** routines that [sqlite3_malloc()] may call. -** -** ^The memory high-water mark is reset to the current value of -** [sqlite3_memory_used()] if and only if the parameter to -** [sqlite3_memory_highwater()] is true. ^The value returned -** by [sqlite3_memory_highwater(1)] is the high-water mark -** prior to the reset. -*/ -SQLITE_API sqlite3_int64 sqlite3_memory_used(void); -SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); - -/* -** CAPI3REF: Pseudo-Random Number Generator -** -** SQLite contains a high-quality pseudo-random number generator (PRNG) used to -** select random [ROWID | ROWIDs] when inserting new records into a table that -** already uses the largest possible [ROWID]. The PRNG is also used for -** the build-in random() and randomblob() SQL functions. This interface allows -** applications to access the same PRNG for other purposes. -** -** ^A call to this routine stores N bytes of randomness into buffer P. -** -** ^The first time this routine is invoked (either internally or by -** the application) the PRNG is seeded using randomness obtained -** from the xRandomness method of the default [sqlite3_vfs] object. -** ^On all subsequent invocations, the pseudo-randomness is generated -** internally and without recourse to the [sqlite3_vfs] xRandomness -** method. -*/ -SQLITE_API void sqlite3_randomness(int N, void *P); - -/* -** CAPI3REF: Compile-Time Authorization Callbacks -** -** ^This routine registers a authorizer callback with a particular -** [database connection], supplied in the first argument. -** ^The authorizer callback is invoked as SQL statements are being compiled -** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], -** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various -** points during the compilation process, as logic is being created -** to perform various actions, the authorizer callback is invoked to -** see if those actions are allowed. ^The authorizer callback should -** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the -** specific action but allow the SQL statement to continue to be -** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be -** rejected with an error. ^If the authorizer callback returns -** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] -** then the [sqlite3_prepare_v2()] or equivalent call that triggered -** the authorizer will fail with an error message. -** -** When the callback returns [SQLITE_OK], that means the operation -** requested is ok. ^When the callback returns [SQLITE_DENY], the -** [sqlite3_prepare_v2()] or equivalent call that triggered the -** authorizer will fail with an error message explaining that -** access is denied. -** -** ^The first parameter to the authorizer callback is a copy of the third -** parameter to the sqlite3_set_authorizer() interface. ^The second parameter -** to the callback is an integer [SQLITE_COPY | action code] that specifies -** the particular action to be authorized. ^The third through sixth parameters -** to the callback are zero-terminated strings that contain additional -** details about the action to be authorized. -** -** ^If the action code is [SQLITE_READ] -** and the callback returns [SQLITE_IGNORE] then the -** [prepared statement] statement is constructed to substitute -** a NULL value in place of the table column that would have -** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] -** return can be used to deny an untrusted user access to individual -** columns of a table. -** ^If the action code is [SQLITE_DELETE] and the callback returns -** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the -** [truncate optimization] is disabled and all rows are deleted individually. -** -** An authorizer is used when [sqlite3_prepare | preparing] -** SQL statements from an untrusted source, to ensure that the SQL statements -** do not try to access data they are not allowed to see, or that they do not -** try to execute malicious statements that damage the database. For -** example, an application may allow a user to enter arbitrary -** SQL queries for evaluation by a database. But the application does -** not want the user to be able to make arbitrary changes to the -** database. An authorizer could then be put in place while the -** user-entered SQL is being [sqlite3_prepare | prepared] that -** disallows everything except [SELECT] statements. -** -** Applications that need to process SQL from untrusted sources -** might also consider lowering resource limits using [sqlite3_limit()] -** and limiting database size using the [max_page_count] [PRAGMA] -** in addition to using an authorizer. -** -** ^(Only a single authorizer can be in place on a database connection -** at a time. Each call to sqlite3_set_authorizer overrides the -** previous call.)^ ^Disable the authorizer by installing a NULL callback. -** The authorizer is disabled by default. -** -** The authorizer callback must not do anything that will modify -** the database connection that invoked the authorizer callback. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the -** statement might be re-prepared during [sqlite3_step()] due to a -** schema change. Hence, the application should ensure that the -** correct authorizer callback remains in place during the [sqlite3_step()]. -** -** ^Note that the authorizer callback is invoked only during -** [sqlite3_prepare()] or its variants. Authorization is not -** performed during statement evaluation in [sqlite3_step()], unless -** as stated in the previous paragraph, sqlite3_step() invokes -** sqlite3_prepare_v2() to reprepare a statement after a schema change. -*/ -SQLITE_API int sqlite3_set_authorizer( - sqlite3*, - int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), - void *pUserData -); - -/* -** CAPI3REF: Authorizer Return Codes -** -** The [sqlite3_set_authorizer | authorizer callback function] must -** return either [SQLITE_OK] or one of these two constants in order -** to signal SQLite whether or not the action is permitted. See the -** [sqlite3_set_authorizer | authorizer documentation] for additional -** information. -*/ -#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ -#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ - -/* -** CAPI3REF: Authorizer Action Codes -** -** The [sqlite3_set_authorizer()] interface registers a callback function -** that is invoked to authorize certain SQL statement actions. The -** second parameter to the callback is an integer code that specifies -** what action is being authorized. These are the integer action codes that -** the authorizer callback may be passed. -** -** These action code values signify what kind of operation is to be -** authorized. The 3rd and 4th parameters to the authorization -** callback function will be parameters or NULL depending on which of these -** codes is used as the second parameter. ^(The 5th parameter to the -** authorizer callback is the name of the database ("main", "temp", -** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback -** is the name of the inner-most trigger or view that is responsible for -** the access attempt or NULL if this access attempt is directly from -** top-level SQL code. -*/ -/******************************************* 3rd ************ 4th ***********/ -#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ -#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ -#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ -#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ -#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ -#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ -#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ -#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ -#define SQLITE_DELETE 9 /* Table Name NULL */ -#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ -#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ -#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ -#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ -#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ -#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ -#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ -#define SQLITE_DROP_VIEW 17 /* View Name NULL */ -#define SQLITE_INSERT 18 /* Table Name NULL */ -#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ -#define SQLITE_READ 20 /* Table Name Column Name */ -#define SQLITE_SELECT 21 /* NULL NULL */ -#define SQLITE_TRANSACTION 22 /* Operation NULL */ -#define SQLITE_UPDATE 23 /* Table Name Column Name */ -#define SQLITE_ATTACH 24 /* Filename NULL */ -#define SQLITE_DETACH 25 /* Database Name NULL */ -#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ -#define SQLITE_REINDEX 27 /* Index Name NULL */ -#define SQLITE_ANALYZE 28 /* Table Name NULL */ -#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ -#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ -#define SQLITE_FUNCTION 31 /* NULL Function Name */ -#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ -#define SQLITE_COPY 0 /* No longer used */ - -/* -** CAPI3REF: Tracing And Profiling Functions -** EXPERIMENTAL -** -** These routines register callback functions that can be used for -** tracing and profiling the execution of SQL statements. -** -** ^The callback function registered by sqlite3_trace() is invoked at -** various times when an SQL statement is being run by [sqlite3_step()]. -** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the -** SQL statement text as the statement first begins executing. -** ^(Additional sqlite3_trace() callbacks might occur -** as each triggered subprogram is entered. The callbacks for triggers -** contain a UTF-8 SQL comment that identifies the trigger.)^ -** -** ^The callback function registered by sqlite3_profile() is invoked -** as each SQL statement finishes. ^The profile callback contains -** the original statement text and an estimate of wall-clock time -** of how long that statement took to run. -*/ -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, - void(*xProfile)(void*,const char*,sqlite3_uint64), void*); - -/* -** CAPI3REF: Query Progress Callbacks -** -** ^This routine configures a callback function - the -** progress callback - that is invoked periodically during long -** running calls to [sqlite3_exec()], [sqlite3_step()] and -** [sqlite3_get_table()]. An example use for this -** interface is to keep a GUI updated during a large query. -** -** ^If the progress callback returns non-zero, the operation is -** interrupted. This feature can be used to implement a -** "Cancel" button on a GUI progress dialog box. -** -** The progress handler must not do anything that will modify -** the database connection that invoked the progress handler. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -*/ -SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); - -/* -** CAPI3REF: Opening A New Database Connection -** -** ^These routines open an SQLite database file whose name is given by the -** filename argument. ^The filename argument is interpreted as UTF-8 for -** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte -** order for sqlite3_open16(). ^(A [database connection] handle is usually -** returned in *ppDb, even if an error occurs. The only exception is that -** if SQLite is unable to allocate memory to hold the [sqlite3] object, -** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] -** object.)^ ^(If the database is opened (and/or created) successfully, then -** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The -** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain -** an English language description of the error following a failure of any -** of the sqlite3_open() routines. -** -** ^The default encoding for the database will be UTF-8 if -** sqlite3_open() or sqlite3_open_v2() is called and -** UTF-16 in the native byte order if sqlite3_open16() is used. -** -** Whether or not an error occurs when it is opened, resources -** associated with the [database connection] handle should be released by -** passing it to [sqlite3_close()] when it is no longer required. -** -** The sqlite3_open_v2() interface works like sqlite3_open() -** except that it accepts two additional parameters for additional control -** over the new database connection. ^(The flags parameter to -** sqlite3_open_v2() can take one of -** the following three values, optionally combined with the -** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], -** and/or [SQLITE_OPEN_PRIVATECACHE] flags:)^ -** -**
-** ^(
[SQLITE_OPEN_READONLY]
-**
The database is opened in read-only mode. If the database does not -** already exist, an error is returned.
)^ -** -** ^(
[SQLITE_OPEN_READWRITE]
-**
The database is opened for reading and writing if possible, or reading -** only if the file is write protected by the operating system. In either -** case the database must already exist, otherwise an error is returned.
)^ -** -** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
-**
The database is opened for reading and writing, and is creates it if -** it does not already exist. This is the behavior that is always used for -** sqlite3_open() and sqlite3_open16().
)^ -**
-** -** If the 3rd parameter to sqlite3_open_v2() is not one of the -** combinations shown above or one of the combinations shown above combined -** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], -** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags, -** then the behavior is undefined. -** -** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection -** opens in the multi-thread [threading mode] as long as the single-thread -** mode has not been set at compile-time or start-time. ^If the -** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens -** in the serialized [threading mode] unless single-thread was -** 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 -** is created for the connection. ^This in-memory database will vanish when -** the database connection is closed. Future versions of SQLite might -** make use of additional special filenames that begin with the ":" character. -** It is recommended that when a database filename actually does begin with -** a ":" character you should prefix the filename with a pathname such as -** "./" to avoid ambiguity. -** -** ^If the filename is an empty string, then a private, temporary -** on-disk database will be created. ^This private database will be -** automatically deleted as soon as the database connection is closed. -** -** ^The fourth parameter to sqlite3_open_v2() is the name of the -** [sqlite3_vfs] object that defines the operating system interface that -** the new database connection should use. ^If the fourth parameter is -** a NULL pointer then the default [sqlite3_vfs] object is used. -** -** Note to Windows users: The encoding used for the filename argument -** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever -** codepage is currently defined. Filenames containing international -** characters must be converted to UTF-8 prior to passing them into -** sqlite3_open() or sqlite3_open_v2(). -*/ -SQLITE_API int sqlite3_open( - const char *filename, /* Database filename (UTF-8) */ - sqlite3 **ppDb /* OUT: SQLite db handle */ -); -SQLITE_API int sqlite3_open16( - const void *filename, /* Database filename (UTF-16) */ - sqlite3 **ppDb /* OUT: SQLite db handle */ -); -SQLITE_API int sqlite3_open_v2( - const char *filename, /* Database filename (UTF-8) */ - sqlite3 **ppDb, /* OUT: SQLite db handle */ - int flags, /* Flags */ - const char *zVfs /* Name of VFS module to use */ -); - -/* -** CAPI3REF: Error Codes And Messages -** -** ^The sqlite3_errcode() interface returns the numeric [result code] or -** [extended result code] for the most recent failed sqlite3_* API call -** associated with a [database connection]. If a prior API call failed -** but the most recent API call succeeded, 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 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. -** The application does not need to worry about freeing the result. -** However, the error string might be overwritten or deallocated by -** subsequent calls to other SQLite interface functions.)^ -** -** When the serialized [threading mode] is in use, it might be the -** case that a second error occurs on a separate thread in between -** the time of the first error and the call to these interfaces. -** When that happens, the second error will be reported since these -** interfaces always report the most recent result. To avoid -** this, each thread can obtain exclusive use of the [database connection] D -** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning -** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after -** all calls to the interfaces listed here are completed. -** -** If an interface fails with SQLITE_MISUSE, that means the interface -** was invoked incorrectly by the application. In that case, the -** error code and message may or may not be set. -*/ -SQLITE_API int sqlite3_errcode(sqlite3 *db); -SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); -SQLITE_API const char *sqlite3_errmsg(sqlite3*); -SQLITE_API const void *sqlite3_errmsg16(sqlite3*); - -/* -** CAPI3REF: SQL Statement Object -** KEYWORDS: {prepared statement} {prepared statements} -** -** An instance of this object represents a single SQL statement. -** This object is variously known as a "prepared statement" or a -** "compiled SQL statement" or simply as a "statement". -** -** The life of a statement object goes something like this: -** -**
    -**
  1. Create the object using [sqlite3_prepare_v2()] or a related -** function. -**
  2. Bind values to [host parameters] using the sqlite3_bind_*() -** interfaces. -**
  3. Run the SQL by calling [sqlite3_step()] one or more times. -**
  4. Reset the statement using [sqlite3_reset()] then go back -** to step 2. Do this zero or more times. -**
  5. Destroy the object using [sqlite3_finalize()]. -**
-** -** Refer to documentation on individual methods above for additional -** information. -*/ -typedef struct sqlite3_stmt sqlite3_stmt; - -/* -** CAPI3REF: Run-time Limits -** -** ^(This interface allows the size of various constructs to be limited -** on a connection by connection basis. The first parameter is the -** [database connection] whose limit is to be set or queried. The -** second parameter is one of the [limit categories] that define a -** class of constructs to be size limited. The third parameter is the -** new limit for that construct. The function returns the old limit.)^ -** -** ^If the new limit is a negative number, the limit is unchanged. -** ^(For the limit category of SQLITE_LIMIT_XYZ there is a -** [limits | hard upper bound] -** set by a compile-time C preprocessor macro named -** [limits | SQLITE_MAX_XYZ]. -** (The "_LIMIT_" in the name is changed to "_MAX_".))^ -** ^Attempts to increase a limit above its hard upper bound are -** silently truncated to the hard upper bound. -** -** Run-time limits are intended for use in applications that manage -** both their own internal database and also databases that are controlled -** by untrusted external sources. An example application might be a -** web browser that has its own databases for storing history and -** separate databases controlled by JavaScript applications downloaded -** off the Internet. The internal databases can be given the -** large, default limits. Databases managed by external sources can -** be given much smaller limits designed to prevent a denial of service -** attack. Developers might also want to use the [sqlite3_set_authorizer()] -** interface to further control untrusted SQL. The size of the database -** created by an untrusted script can be contained using the -** [max_page_count] [PRAGMA]. -** -** New run-time limit categories may be added in future releases. -*/ -SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); - -/* -** CAPI3REF: Run-Time Limit Categories -** KEYWORDS: {limit category} {*limit categories} -** -** These constants define various performance limits -** that can be lowered at run-time using [sqlite3_limit()]. -** The synopsis of the meanings of the various limits is shown below. -** Additional information is available at [limits | Limits in SQLite]. -** -**
-** ^(
SQLITE_LIMIT_LENGTH
-**
The maximum size of any string or BLOB or table row.
)^ -** -** ^(
SQLITE_LIMIT_SQL_LENGTH
-**
The maximum length of an SQL statement, in bytes.
)^ -** -** ^(
SQLITE_LIMIT_COLUMN
-**
The maximum number of columns in a table definition or in the -** result set of a [SELECT] or the maximum number of columns in an index -** or in an ORDER BY or GROUP BY clause.
)^ -** -** ^(
SQLITE_LIMIT_EXPR_DEPTH
-**
The maximum depth of the parse tree on any expression.
)^ -** -** ^(
SQLITE_LIMIT_COMPOUND_SELECT
-**
The maximum number of terms in a compound SELECT statement.
)^ -** -** ^(
SQLITE_LIMIT_VDBE_OP
-**
The maximum number of instructions in a virtual machine program -** used to implement an SQL statement.
)^ -** -** ^(
SQLITE_LIMIT_FUNCTION_ARG
-**
The maximum number of arguments on a function.
)^ -** -** ^(
SQLITE_LIMIT_ATTACHED
-**
The maximum number of [ATTACH | attached databases].)^
-** -** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
-**
The maximum length of the pattern argument to the [LIKE] or -** [GLOB] operators.
)^ -** -** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
-**
The maximum number of variables in an SQL statement that can -** be bound.
)^ -** -** ^(
SQLITE_LIMIT_TRIGGER_DEPTH
-**
The maximum depth of recursion for triggers.
)^ -**
-*/ -#define SQLITE_LIMIT_LENGTH 0 -#define SQLITE_LIMIT_SQL_LENGTH 1 -#define SQLITE_LIMIT_COLUMN 2 -#define SQLITE_LIMIT_EXPR_DEPTH 3 -#define SQLITE_LIMIT_COMPOUND_SELECT 4 -#define SQLITE_LIMIT_VDBE_OP 5 -#define SQLITE_LIMIT_FUNCTION_ARG 6 -#define SQLITE_LIMIT_ATTACHED 7 -#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 -#define SQLITE_LIMIT_VARIABLE_NUMBER 9 -#define SQLITE_LIMIT_TRIGGER_DEPTH 10 - -/* -** CAPI3REF: Compiling An SQL Statement -** KEYWORDS: {SQL statement compiler} -** -** To execute an SQL query, it must first be compiled into a byte-code -** program using one of these routines. -** -** The first argument, "db", is a [database connection] obtained from a -** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or -** [sqlite3_open16()]. The database connection must not have been closed. -** -** The second argument, "zSql", is the statement to be compiled, encoded -** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() -** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() -** use UTF-16. -** -** ^If the nByte argument is less than zero, then zSql is read up to the -** first zero terminator. ^If nByte is non-negative, then it is the maximum -** number of bytes read from zSql. ^When nByte is non-negative, the -** zSql string ends at either the first '\000' or '\u0000' character or -** the nByte-th byte, whichever comes first. If the caller knows -** that the supplied string is nul-terminated, then there is a small -** performance advantage to be gained by passing an nByte parameter that -** is equal to the number of bytes in the input string including -** the nul-terminator bytes. -** -** ^If pzTail is not NULL then *pzTail is made to point to the first byte -** past the end of the first SQL statement in zSql. These routines only -** compile the first statement in zSql, so *pzTail is left pointing to -** what remains uncompiled. -** -** ^*ppStmt is left pointing to a compiled [prepared statement] that can be -** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set -** to NULL. ^If the input text contains no SQL (if the input is an empty -** string or a comment) then *ppStmt is set to NULL. -** The calling procedure is responsible for deleting the compiled -** SQL statement using [sqlite3_finalize()] after it has finished with it. -** ppStmt may not be NULL. -** -** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; -** otherwise an [error code] is returned. -** -** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are -** recommended for all new programs. The two older interfaces are retained -** for backwards compatibility, but their use is discouraged. -** ^In the "v2" interfaces, the prepared statement -** that is returned (the [sqlite3_stmt] object) contains a copy of the -** original SQL text. This causes the [sqlite3_step()] interface to -** behave differently in three ways: -** -**
    -**
  1. -** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it -** always used to do, [sqlite3_step()] will automatically recompile the SQL -** statement and try to run it again. ^If the schema has changed in -** a way that makes the statement no longer valid, [sqlite3_step()] will still -** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is -** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the -** error go away. Note: use [sqlite3_errmsg()] to find the text -** of the parsing error that results in an [SQLITE_SCHEMA] return. -**
    2. -** -**
  2. -** ^When an error occurs, [sqlite3_step()] will return one of the detailed -** [error codes] or [extended error codes]. ^The legacy behavior was that -** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code -** and the application would have to make a second call to [sqlite3_reset()] -** in order to find the underlying cause of the problem. With the "v2" prepare -** interfaces, the underlying reason for the error is returned immediately. -**
    3. -** -**
  3. -** ^If the value of a [parameter | host parameter] in the WHERE clause might -** change the query plan for a statement, then the statement may be -** automatically recompiled (as if there had been a schema change) on the first -** [sqlite3_step()] call following any change to the -** [sqlite3_bind_text | bindings] of the [parameter]. -**
    4. -**
-*/ -SQLITE_API int sqlite3_prepare( - sqlite3 *db, /* Database handle */ - const char *zSql, /* SQL statement, UTF-8 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const char **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare_v2( - sqlite3 *db, /* Database handle */ - const char *zSql, /* SQL statement, UTF-8 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const char **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare16( - sqlite3 *db, /* Database handle */ - const void *zSql, /* SQL statement, UTF-16 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const void **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare16_v2( - sqlite3 *db, /* Database handle */ - const void *zSql, /* SQL statement, UTF-16 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const void **pzTail /* OUT: Pointer to unused portion of zSql */ -); - -/* -** CAPI3REF: Retrieving Statement SQL -** -** ^This interface can be used to retrieve a saved copy of the original -** SQL text used to create a [prepared statement] if that statement was -** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. -*/ -SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Dynamically Typed Value Object -** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} -** -** SQLite uses the sqlite3_value object to represent all values -** that can be stored in a database table. SQLite uses dynamic typing -** for the values it stores. ^Values stored in sqlite3_value objects -** can be integers, floating point values, strings, BLOBs, or NULL. -** -** An sqlite3_value object may be either "protected" or "unprotected". -** Some interfaces require a protected sqlite3_value. Other interfaces -** will accept either a protected or an unprotected sqlite3_value. -** Every interface that accepts sqlite3_value arguments specifies -** whether or not it requires a protected sqlite3_value. -** -** The terms "protected" and "unprotected" refer to whether or not -** a mutex is held. A internal mutex is held for a protected -** sqlite3_value object but no mutex is held for an unprotected -** sqlite3_value object. If SQLite is compiled to be single-threaded -** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) -** or if SQLite is run in one of reduced mutex modes -** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] -** then there is no distinction between protected and unprotected -** sqlite3_value objects and they can be used interchangeably. However, -** for maximum code portability it is recommended that applications -** still make the distinction between between protected and unprotected -** sqlite3_value objects even when not strictly required. -** -** ^The sqlite3_value objects that are passed as parameters into the -** implementation of [application-defined SQL functions] are protected. -** ^The sqlite3_value object returned by -** [sqlite3_column_value()] is unprotected. -** Unprotected sqlite3_value objects may only be used with -** [sqlite3_result_value()] and [sqlite3_bind_value()]. -** The [sqlite3_value_blob | sqlite3_value_type()] family of -** interfaces require protected sqlite3_value objects. -*/ -typedef struct Mem sqlite3_value; - -/* -** CAPI3REF: SQL Function Context Object -** -** The context in which an SQL function executes is stored in an -** sqlite3_context object. ^A pointer to an sqlite3_context object -** is always first parameter to [application-defined SQL functions]. -** The application-defined SQL function implementation will pass this -** pointer through into calls to [sqlite3_result_int | sqlite3_result()], -** [sqlite3_aggregate_context()], [sqlite3_user_data()], -** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], -** and/or [sqlite3_set_auxdata()]. -*/ -typedef struct sqlite3_context sqlite3_context; - -/* -** CAPI3REF: Binding Values To Prepared Statements -** KEYWORDS: {host parameter} {host parameters} {host parameter name} -** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} -** -** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, -** literals may be replaced by a [parameter] that matches one of following -** templates: -** -**
    -**
  • ? -**
  • ?NNN -**
  • :VVV -**
  • @VVV -**
  • $VVV -**
-** -** In the templates above, NNN represents an integer literal, -** and VVV represents an alphanumeric identifer.)^ ^The values of these -** parameters (also called "host parameter names" or "SQL parameters") -** can be set using the sqlite3_bind_*() routines defined here. -** -** ^The first argument to the sqlite3_bind_*() routines is always -** a pointer to the [sqlite3_stmt] object returned from -** [sqlite3_prepare_v2()] or its variants. -** -** ^The second argument is the index of the SQL parameter to be set. -** ^The leftmost SQL parameter has an index of 1. ^When the same named -** SQL parameter is used more than once, second and subsequent -** occurrences have the same index as the first occurrence. -** ^The index for named parameters can be looked up using the -** [sqlite3_bind_parameter_index()] API if desired. ^The index -** for "?NNN" parameters is the value of NNN. -** ^The NNN value must be between 1 and the [sqlite3_limit()] -** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). -** -** ^The third argument is the value to bind to the parameter. -** -** ^(In those routines that have a fourth argument, its value is the -** number of bytes in the parameter. To be clear: the value is the -** number of bytes in the value, not the number of characters.)^ -** ^If the fourth parameter is negative, the length of the string is -** the number of bytes up to the first zero terminator. -** -** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and -** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^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. -** ^If the fifth argument has the value [SQLITE_TRANSIENT], then -** SQLite makes its own private copy of the data immediately, before -** the sqlite3_bind_*() routine returns. -** -** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that -** is filled with zeroes. ^A zeroblob uses a fixed amount of memory -** (just an integer to hold its size) while it is being processed. -** Zeroblobs are intended to serve as placeholders for BLOBs whose -** content is later written using -** [sqlite3_blob_open | incremental BLOB I/O] routines. -** ^A negative value for the zeroblob results in a zero-length BLOB. -** -** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer -** for the [prepared statement] or with a prepared statement for which -** [sqlite3_step()] has been called more recently than [sqlite3_reset()], -** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() -** routine is passed a [prepared statement] that has been finalized, the -** result is undefined and probably harmful. -** -** ^Bindings are not cleared by the [sqlite3_reset()] routine. -** ^Unbound parameters are interpreted as NULL. -** -** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an -** [error code] if anything goes wrong. -** ^[SQLITE_RANGE] is returned if the parameter -** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. -** -** See also: [sqlite3_bind_parameter_count()], -** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); -SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); -SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); -SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); -SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); -SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); -SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); -SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); -SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); - -/* -** CAPI3REF: Number Of SQL Parameters -** -** ^This routine can be used to find the number of [SQL parameters] -** in a [prepared statement]. SQL parameters are tokens of the -** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as -** placeholders for values that are [sqlite3_bind_blob | bound] -** to the parameters at a later time. -** -** ^(This routine actually returns the index of the largest (rightmost) -** parameter. For all forms except ?NNN, this will correspond to the -** number of unique parameters. If parameters of the ?NNN form are used, -** there may be gaps in the list.)^ -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_name()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); - -/* -** CAPI3REF: Name Of A Host Parameter -** -** ^The sqlite3_bind_parameter_name(P,N) interface returns -** the name of the N-th [SQL parameter] in the [prepared statement] P. -** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" -** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" -** respectively. -** In other words, the initial ":" or "$" or "@" or "?" -** is included as part of the name.)^ -** ^Parameters of the form "?" without a following integer have no name -** and are referred to as "nameless" or "anonymous parameters". -** -** ^The first host parameter has an index of 1, not 0. -** -** ^If the value N is out of range or if the N-th parameter is -** nameless, then NULL is returned. ^The returned string is -** always in UTF-8 encoding even if the named parameter was -** originally specified as UTF-16 in [sqlite3_prepare16()] or -** [sqlite3_prepare16_v2()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); - -/* -** CAPI3REF: Index Of A Parameter With A Given Name -** -** ^Return the index of an SQL parameter given its name. ^The -** index value returned is suitable for use as the second -** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero -** is returned if no matching parameter is found. ^The parameter -** name must be given in UTF-8 even if the original statement -** was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); - -/* -** CAPI3REF: Reset All Bindings On A Prepared Statement -** -** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset -** the [sqlite3_bind_blob | bindings] on a [prepared statement]. -** ^Use this routine to reset all host parameters to NULL. -*/ -SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); - -/* -** CAPI3REF: Number Of Columns In A Result Set -** -** ^Return the number of columns in the result set returned by the -** [prepared statement]. ^This routine returns 0 if pStmt is an SQL -** statement that does not return data (for example an [UPDATE]). -*/ -SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Column Names In A Result Set -** -** ^These routines return the name assigned to a particular column -** in the result set of a [SELECT] statement. ^The sqlite3_column_name() -** interface returns a pointer to a zero-terminated UTF-8 string -** and sqlite3_column_name16() returns a pointer to a zero-terminated -** UTF-16 string. ^The first parameter is the [prepared statement] -** that implements the [SELECT] statement. ^The second parameter is the -** column number. ^The leftmost column is number 0. -** -** ^The returned string pointer is valid until either the [prepared statement] -** is destroyed by [sqlite3_finalize()] or until the next call to -** sqlite3_column_name() or sqlite3_column_name16() on the same column. -** -** ^If sqlite3_malloc() fails during the processing of either routine -** (for example during a conversion from UTF-8 to UTF-16) then a -** NULL pointer is returned. -** -** ^The name of a result column is the value of the "AS" clause for -** that column, if there is an AS clause. If there is no AS clause -** then the name of the column is unspecified and may change from -** one release of SQLite to the next. -*/ -SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); -SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); - -/* -** CAPI3REF: Source Of Data In A Query Result -** -** ^These routines provide a means to determine the database, table, and -** table column that is the origin of a particular result column in -** [SELECT] statement. -** ^The name of the database or table or column can be returned as -** either a UTF-8 or UTF-16 string. ^The _database_ routines return -** the database name, the _table_ routines return the table name, and -** the origin_ routines return the column name. -** ^The returned string is valid until the [prepared statement] is destroyed -** using [sqlite3_finalize()] or until the same information is requested -** again in a different encoding. -** -** ^The names returned are the original un-aliased names of the -** database, table, and column. -** -** ^The first argument to these interfaces is a [prepared statement]. -** ^These functions return information about the Nth result column returned by -** the statement, where N is the second function argument. -** ^The left-most column is column 0 for these routines. -** -** ^If the Nth column returned by the statement is an expression or -** subquery and is not a column value, then all of these functions return -** NULL. ^These routine might also return NULL if a memory allocation error -** occurs. ^Otherwise, they return the name of the attached database, table, -** or column that query result column was extracted from. -** -** ^As with all other SQLite APIs, those whose names end with "16" return -** UTF-16 encoded strings and the other functions return UTF-8. -** -** ^These APIs are only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. -** -** If two or more threads call one or more of these routines against the same -** prepared statement and column at the same time then the results are -** undefined. -** -** If two or more threads call one or more -** [sqlite3_column_database_name | column metadata interfaces] -** for the same [prepared statement] and result column -** at the same time then the results are undefined. -*/ -SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); -SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); -SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); - -/* -** CAPI3REF: Declared Datatype Of A Query Result -** -** ^(The first parameter is a [prepared statement]. -** If this statement is a [SELECT] statement and the Nth column of the -** returned result set of that [SELECT] is a table column (not an -** expression or subquery) then the declared type of the table -** column is returned.)^ ^If the Nth column of the result set is an -** expression or subquery, then a NULL pointer is returned. -** ^The returned string is always UTF-8 encoded. -** -** ^(For example, given the database schema: -** -** CREATE TABLE t1(c1 VARIANT); -** -** and the following statement to be compiled: -** -** SELECT c1 + 1, c1 FROM t1; -** -** this routine would return the string "VARIANT" for the second result -** column (i==1), and a NULL pointer for the first result column (i==0).)^ -** -** ^SQLite uses dynamic run-time typing. ^So just because a column -** is declared to contain a particular type does not mean that the -** data stored in that column is of the declared type. SQLite is -** strongly typed, but the typing is dynamic not static. ^Type -** is associated with individual values, not with the containers -** used to hold those values. -*/ -SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); - -/* -** CAPI3REF: Evaluate An SQL Statement -** -** After a [prepared statement] has been prepared using either -** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy -** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function -** must be called one or more times to evaluate the statement. -** -** The details of the behavior of the sqlite3_step() interface depend -** on whether the statement was prepared using the newer "v2" interface -** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy -** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the -** new "v2" interface is recommended for new applications but the legacy -** interface will continue to be supported. -** -** ^In the legacy interface, the return value will be either [SQLITE_BUSY], -** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. -** ^With the "v2" interface, any of the other [result codes] or -** [extended result codes] might be returned as well. -** -** ^[SQLITE_BUSY] means that the database engine was unable to acquire the -** database locks it needs to do its job. ^If the statement is a [COMMIT] -** or occurs outside of an explicit transaction, then you can retry the -** statement. If the statement is not a [COMMIT] and occurs within a -** explicit transaction then you should rollback the transaction before -** continuing. -** -** ^[SQLITE_DONE] means that the statement has finished executing -** successfully. sqlite3_step() should not be called again on this virtual -** machine without first calling [sqlite3_reset()] to reset the virtual -** machine back to its initial state. -** -** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] -** is returned each time a new row of data is ready for processing by the -** caller. The values may be accessed using the [column access functions]. -** sqlite3_step() is called again to retrieve the next row of data. -** -** ^[SQLITE_ERROR] means that a run-time error (such as a constraint -** violation) has occurred. sqlite3_step() should not be called again on -** the VM. More information may be found by calling [sqlite3_errmsg()]. -** ^With the legacy interface, a more specific error code (for example, -** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) -** can be obtained by calling [sqlite3_reset()] on the -** [prepared statement]. ^In the "v2" interface, -** the more specific error code is returned directly by sqlite3_step(). -** -** [SQLITE_MISUSE] means that the this routine was called inappropriately. -** Perhaps it was called on a [prepared statement] that has -** already been [sqlite3_finalize | finalized] or on one that had -** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could -** be the case that the same database connection is being used by two or -** more threads at the same moment in time. -** -** Goofy Interface Alert: In the legacy interface, the sqlite3_step() -** API always returns a generic error code, [SQLITE_ERROR], following any -** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call -** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the -** specific [error codes] that better describes the error. -** We admit that this is a goofy design. The problem has been fixed -** with the "v2" interface. If you prepare all of your SQL statements -** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead -** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, -** then the more specific [error codes] are returned directly -** by sqlite3_step(). The use of the "v2" interface is recommended. -*/ -SQLITE_API int sqlite3_step(sqlite3_stmt*); - -/* -** CAPI3REF: Number of columns in a result set -** -** ^The sqlite3_data_count(P) the number of columns in the -** of the result set of [prepared statement] P. -*/ -SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Fundamental Datatypes -** KEYWORDS: SQLITE_TEXT -** -** ^(Every value in SQLite has one of five fundamental datatypes: -** -**
    -**
  • 64-bit signed integer -**
  • 64-bit IEEE floating point number -**
  • string -**
  • BLOB -**
  • NULL -**
)^ -** -** These constants are codes for each of those types. -** -** Note that the SQLITE_TEXT constant was also used in SQLite version 2 -** for a completely different meaning. Software that links against both -** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not -** SQLITE_TEXT. -*/ -#define SQLITE_INTEGER 1 -#define SQLITE_FLOAT 2 -#define SQLITE_BLOB 4 -#define SQLITE_NULL 5 -#ifdef SQLITE_TEXT -# undef SQLITE_TEXT -#else -# define SQLITE_TEXT 3 -#endif -#define SQLITE3_TEXT 3 - -/* -** CAPI3REF: Result Values From A Query -** KEYWORDS: {column access functions} -** -** These routines form the "result set" interface. -** -** ^These routines return information about a single column of the current -** result row of a query. ^In every case the first argument is a pointer -** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] -** that was returned from [sqlite3_prepare_v2()] or one of its variants) -** and the second argument is the index of the column for which information -** should be returned. ^The leftmost column of the result set has the index 0. -** ^The number of columns in the result can be determined using -** [sqlite3_column_count()]. -** -** If the SQL statement does not currently point to a valid row, or if the -** column index is out of range, the result is undefined. -** These routines may only be called when the most recent call to -** [sqlite3_step()] has returned [SQLITE_ROW] and neither -** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. -** If any of these routines are called after [sqlite3_reset()] or -** [sqlite3_finalize()] or after [sqlite3_step()] has returned -** something other than [SQLITE_ROW], the results are undefined. -** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] -** are called from a different thread while any of these routines -** are pending, then the results are undefined. -** -** ^The sqlite3_column_type() routine returns the -** [SQLITE_INTEGER | datatype code] for the initial data type -** of the result column. ^The returned value is one of [SQLITE_INTEGER], -** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value -** returned by sqlite3_column_type() is only meaningful if no type -** conversions have occurred as described below. After a type conversion, -** the value returned by sqlite3_column_type() is undefined. Future -** versions of SQLite may change the behavior of sqlite3_column_type() -** following a type conversion. -** -** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() -** routine returns the number of bytes in that BLOB or string. -** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts -** the string to UTF-8 and then returns the number of bytes. -** ^If the result is a numeric value then sqlite3_column_bytes() uses -** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns -** the number of bytes in that string. -** ^The value returned does not include the zero terminator at the end -** of the string. ^For clarity: the value returned is the number of -** bytes in the string, not the number of characters. -** -** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), -** even empty strings, are always zero terminated. ^The return -** value from sqlite3_column_blob() for a zero-length BLOB is an arbitrary -** pointer, possibly even a NULL pointer. -** -** ^The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() -** but leaves the result in UTF-16 in native byte order instead of UTF-8. -** ^The zero terminator is not included in this count. -** -** ^The object returned by [sqlite3_column_value()] is an -** [unprotected sqlite3_value] object. An unprotected sqlite3_value object -** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. -** If the [unprotected sqlite3_value] object returned by -** [sqlite3_column_value()] is used in any other way, including calls -** to routines like [sqlite3_value_int()], [sqlite3_value_text()], -** or [sqlite3_value_bytes()], then the behavior is undefined. -** -** These routines attempt to convert the value where appropriate. ^For -** example, if the internal representation is FLOAT and a text result -** is requested, [sqlite3_snprintf()] is used internally to perform the -** conversion automatically. ^(The following table details the conversions -** that are applied: -** -**
-** -**
Internal
Type 		Requested
Type 		Conversion -** -**
NULL INTEGER Result is 0 -**
NULL FLOAT Result is 0.0 -**
NULL TEXT Result is NULL pointer -**
NULL BLOB Result is NULL pointer -**
INTEGER FLOAT Convert from integer to float -**
INTEGER TEXT ASCII rendering of the integer -**
INTEGER BLOB Same as INTEGER->TEXT -**
FLOAT INTEGER Convert from float to integer -**
FLOAT TEXT ASCII rendering of the float -**
FLOAT BLOB Same as FLOAT->TEXT -**
TEXT INTEGER Use atoi() -**
TEXT FLOAT Use atof() -**
TEXT BLOB No change -**
BLOB INTEGER Convert to TEXT then use atoi() -**
BLOB FLOAT Convert to TEXT then use atof() -**
BLOB TEXT Add a zero terminator if needed -**
-**
)^ -** -** The table above makes reference to standard C library functions atoi() -** and atof(). SQLite does not really use these functions. It has its -** own equivalent internal routines. The atoi() and atof() names are -** used in the table for brevity and because they are familiar to most -** C programmers. -** -** ^Note that when type conversions occur, pointers returned by prior -** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or -** sqlite3_column_text16() may be invalidated. -** ^(Type conversions and pointer invalidations might occur -** in the following cases: -** -**
    -**
  • The initial content is a BLOB and sqlite3_column_text() or -** sqlite3_column_text16() is called. A zero-terminator might -** need to be added to the string.
    • -**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or -** sqlite3_column_text16() is called. The content must be converted -** to UTF-16.
    • -**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or -** sqlite3_column_text() is called. The content must be converted -** to UTF-8.
    • -**
)^ -** -** ^Conversions between UTF-16be and UTF-16le are always done in place and do -** not invalidate a prior pointer, though of course the content of the buffer -** that the prior pointer points to will have been modified. Other kinds -** of conversion are done in place when it is possible, but sometimes they -** are not possible and in those cases prior pointers are invalidated. -** -** ^(The safest and easiest to remember policy is to invoke these routines -** in one of the following ways: -** -**
    -**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • -**
)^ -** -** In other words, you should call sqlite3_column_text(), -** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result -** into the desired format, then invoke sqlite3_column_bytes() or -** sqlite3_column_bytes16() to find the size of the result. Do not mix calls -** to sqlite3_column_text() or sqlite3_column_blob() with calls to -** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() -** with calls to sqlite3_column_bytes(). -** -** ^The pointers returned are valid until a type conversion occurs as -** described above, or until [sqlite3_step()] or [sqlite3_reset()] or -** [sqlite3_finalize()] is called. ^The memory space used to hold strings -** and BLOBs is freed automatically. Do not pass the pointers returned -** [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].)^ -*/ -SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); -SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); -SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); -SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); - -/* -** CAPI3REF: Destroy A Prepared Statement Object -** -** ^The sqlite3_finalize() function is called to delete a [prepared statement]. -** ^If the statement was executed successfully or not executed at all, then -** SQLITE_OK is returned. ^If execution of the statement failed then an -** [error code] or [extended error code] is returned. -** -** ^This routine can be called at any point during the execution of the -** [prepared statement]. ^If the virtual machine has not -** completed execution when this routine is called, that is like -** encountering an error or an [sqlite3_interrupt | interrupt]. -** ^Incomplete updates may be rolled back and transactions canceled, -** depending on the circumstances, and the -** [error code] returned will be [SQLITE_ABORT]. -*/ -SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Reset A Prepared Statement Object -** -** The sqlite3_reset() function is called to reset a [prepared statement] -** object back to its initial state, ready to be re-executed. -** ^Any SQL statement variables that had values bound to them using -** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. -** Use [sqlite3_clear_bindings()] to reset the bindings. -** -** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S -** back to the beginning of its program. -** -** ^If the most recent call to [sqlite3_step(S)] for the -** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], -** or if [sqlite3_step(S)] has never before been called on S, -** then [sqlite3_reset(S)] returns [SQLITE_OK]. -** -** ^If the most recent call to [sqlite3_step(S)] for the -** [prepared statement] S indicated an error, then -** [sqlite3_reset(S)] returns an appropriate [error code]. -** -** ^The [sqlite3_reset(S)] interface does not change the values -** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. -*/ -SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Create Or Redefine SQL Functions -** KEYWORDS: {function creation routines} -** KEYWORDS: {application-defined SQL function} -** KEYWORDS: {application-defined SQL functions} -** -** ^These two 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 difference between the -** two is that the second parameter, the name of the (scalar) function or -** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16 -** for sqlite3_create_function16(). -** -** ^The first parameter is the [database connection] to which the SQL -** function is to be added. ^If an application uses more than one database -** connection then application-defined SQL functions must be added -** to each database connection separately. -** -** The second parameter is the name of the SQL function to be created or -** redefined. ^The length of the name is limited to 255 bytes, exclusive of -** the zero-terminator. Note that the name length limit is in bytes, not -** characters. ^Any attempt to create a function with a longer name -** will result in [SQLITE_ERROR] being returned. -** -** ^The third parameter (nArg) -** is the number of arguments that the SQL function or -** aggregate takes. ^If this parameter is -1, then the SQL function or -** aggregate may take any number of arguments between 0 and the limit -** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third -** parameter is less than -1 or greater than 127 then the behavior is -** undefined. -** -** The fourth parameter, eTextRep, specifies what -** [SQLITE_UTF8 | text encoding] this SQL function prefers for -** 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 -** more efficient with one encoding than another. ^An application may -** invoke sqlite3_create_function() or sqlite3_create_function16() multiple -** times with the same function but with different values of eTextRep. -** ^When multiple implementations of the same function are available, SQLite -** will pick the one that involves the least amount of data conversion. -** If there is only a single implementation which does not care what text -** encoding is used, then the fourth argument should be [SQLITE_ANY]. -** -** ^(The fifth parameter is an arbitrary pointer. The implementation of the -** function can gain access to this pointer using [sqlite3_user_data()].)^ -** -** The seventh, eighth and ninth parameters, 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 should be passed as the xStep and xFinal -** parameters. ^An aggregate SQL function requires an implementation of xStep -** and xFinal and NULL should be passed for xFunc. ^To delete an existing -** SQL function or aggregate, pass NULL for all three function callbacks. -** -** ^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 -** the implementation that most closely matches the way in which the -** SQL function is used. ^A function implementation with a non-negative -** nArg parameter is a better match than a function implementation with -** a negative nArg. ^A function where the preferred text encoding -** matches the database encoding is a better -** match than a function where the encoding is different. -** ^A function where the encoding difference is between UTF16le and UTF16be -** is a closer match than a function where the encoding difference is -** between UTF8 and UTF16. -** -** ^Built-in functions may be overloaded by new application-defined functions. -** ^The first application-defined function with a given name overrides all -** built-in functions in the same [database connection] with the same name. -** ^Subsequent application-defined functions of the same name only override -** prior application-defined functions that are an exact match for the -** number of parameters and preferred encoding. -** -** ^An application-defined function is permitted to call other -** SQLite interfaces. However, such calls must not -** close the database connection nor finalize or reset the prepared -** statement in which the function is running. -*/ -SQLITE_API int sqlite3_create_function( - sqlite3 *db, - const char *zFunctionName, - int nArg, - int eTextRep, - void *pApp, - void (*xFunc)(sqlite3_context*,int,sqlite3_value**), - void (*xStep)(sqlite3_context*,int,sqlite3_value**), - void (*xFinal)(sqlite3_context*) -); -SQLITE_API int sqlite3_create_function16( - sqlite3 *db, - const void *zFunctionName, - int nArg, - int eTextRep, - void *pApp, - void (*xFunc)(sqlite3_context*,int,sqlite3_value**), - void (*xStep)(sqlite3_context*,int,sqlite3_value**), - void (*xFinal)(sqlite3_context*) -); - -/* -** CAPI3REF: Text Encodings -** -** These constant define integer codes that represent the various -** text encodings supported by SQLite. -*/ -#define SQLITE_UTF8 1 -#define SQLITE_UTF16LE 2 -#define SQLITE_UTF16BE 3 -#define SQLITE_UTF16 4 /* Use native byte order */ -#define SQLITE_ANY 5 /* sqlite3_create_function only */ -#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ - -/* -** CAPI3REF: Deprecated Functions -** DEPRECATED -** -** These functions are [deprecated]. In order to maintain -** backwards compatibility with older code, these functions continue -** to be supported. However, new applications should avoid -** the use of these functions. To help encourage people to avoid -** using these functions, we are not going to tell you what they do. -*/ -#ifndef SQLITE_OMIT_DEPRECATED -SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); -SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); -SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); -#endif - -/* -** CAPI3REF: Obtaining SQL Function Parameter Values -** -** The C-language implementation of SQL functions and aggregates uses -** this set of interface routines to access the parameter values on -** the function or aggregate. -** -** The xFunc (for scalar functions) or xStep (for aggregates) parameters -** to [sqlite3_create_function()] and [sqlite3_create_function16()] -** define callbacks that implement the SQL functions and aggregates. -** The 4th parameter to these callbacks is an array of pointers to -** [protected sqlite3_value] objects. There is one [sqlite3_value] object for -** each parameter to the SQL function. These routines are used to -** extract values from the [sqlite3_value] objects. -** -** These routines work only with [protected sqlite3_value] objects. -** Any attempt to use these routines on an [unprotected sqlite3_value] -** object results in undefined behavior. -** -** ^These routines work just like the corresponding [column access functions] -** except that these routines take a single [protected sqlite3_value] object -** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. -** -** ^The sqlite3_value_text16() interface extracts a UTF-16 string -** in the native byte-order of the host machine. ^The -** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces -** extract UTF-16 strings as big-endian and little-endian respectively. -** -** ^(The sqlite3_value_numeric_type() interface attempts to apply -** numeric affinity to the value. This means that an attempt is -** made to convert the value to an integer or floating point. If -** such a conversion is possible without loss of information (in other -** words, if the value is a string that looks like a number) -** then the conversion is performed. Otherwise no conversion occurs. -** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ -** -** 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 -** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], -** or [sqlite3_value_text16()]. -** -** These routines must be called from the same thread as -** the SQL function that supplied the [sqlite3_value*] parameters. -*/ -SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); -SQLITE_API double sqlite3_value_double(sqlite3_value*); -SQLITE_API int sqlite3_value_int(sqlite3_value*); -SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); -SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); -SQLITE_API int sqlite3_value_type(sqlite3_value*); -SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); - -/* -** CAPI3REF: Obtain Aggregate Function Context -** -** Implementions of aggregate SQL functions use this -** routine to allocate memory for storing their state. -** -** ^The first time the sqlite3_aggregate_context(C,N) routine is called -** for a particular aggregate function, SQLite -** allocates N of memory, zeroes out that memory, and returns a pointer -** to the new memory. ^On second and subsequent calls to -** sqlite3_aggregate_context() for the same aggregate function instance, -** the same buffer is returned. Sqlite3_aggregate_context() is normally -** called once for each invocation of the xStep callback and then one -** last time when the xFinal callback is invoked. ^(When no rows match -** an aggregate query, the xStep() callback of the aggregate function -** implementation is never called and xFinal() is called exactly once. -** In those cases, sqlite3_aggregate_context() might be called for the -** first time from within xFinal().)^ -** -** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer if N is -** less than or equal to zero or if a memory allocate error occurs. -** -** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is -** determined by the N parameter on first successful call. Changing the -** value of N in subsequent call to sqlite3_aggregate_context() within -** the same aggregate function instance will not resize the memory -** allocation.)^ -** -** ^SQLite automatically frees the memory allocated by -** sqlite3_aggregate_context() when the aggregate query concludes. -** -** The first parameter must be a copy of the -** [sqlite3_context | SQL function context] that is the first parameter -** to the xStep or xFinal callback routine that implements the aggregate -** function. -** -** This routine must be called from the same thread in which -** the aggregate SQL function is running. -*/ -SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); - -/* -** CAPI3REF: User Data For Functions -** -** ^The sqlite3_user_data() interface returns a copy of -** the pointer that was the pUserData parameter (the 5th parameter) -** of the [sqlite3_create_function()] -** and [sqlite3_create_function16()] routines that originally -** registered the application defined function. -** -** This routine must be called from the same thread in which -** the application-defined function is running. -*/ -SQLITE_API void *sqlite3_user_data(sqlite3_context*); - -/* -** CAPI3REF: Database Connection For Functions -** -** ^The sqlite3_context_db_handle() interface returns a copy of -** the pointer to the [database connection] (the 1st parameter) -** of the [sqlite3_create_function()] -** and [sqlite3_create_function16()] routines that originally -** registered the application defined function. -*/ -SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); - -/* -** CAPI3REF: Function Auxiliary Data -** -** The following two functions may be used by scalar SQL functions to -** associate metadata with argument values. If the same value is passed to -** multiple invocations of the same SQL function during query execution, under -** some circumstances the associated metadata may be preserved. This may -** be used, for example, to add a regular-expression matching scalar -** function. The compiled version of the regular expression is stored as -** metadata associated with the SQL value passed as the regular expression -** pattern. The compiled regular expression can be reused on multiple -** invocations of the same function so that the original pattern string -** does not need to be recompiled on each invocation. -** -** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata -** associated by the sqlite3_set_auxdata() function with the Nth argument -** value to the application-defined function. ^If no metadata has been ever -** been set for the Nth argument of the function, or if the corresponding -** function parameter has changed since the meta-data was set, -** then sqlite3_get_auxdata() returns a NULL pointer. -** -** ^The sqlite3_set_auxdata() interface saves the metadata -** pointed to by its 3rd parameter as the metadata for the N-th -** argument of the application-defined function. Subsequent -** calls to sqlite3_get_auxdata() might return this data, if it has -** not been destroyed. -** ^If it is not NULL, SQLite will invoke the destructor -** function given by the 4th parameter to sqlite3_set_auxdata() on -** the metadata when the corresponding function parameter changes -** or when the SQL statement completes, whichever comes first. -** -** SQLite is free to call the destructor and drop metadata on any -** parameter of any function at any time. ^The only guarantee is that -** the destructor will be called before the metadata is dropped. -** -** ^(In practice, metadata is preserved between function calls for -** expressions that are constant at compile time. This includes literal -** values and [parameters].)^ -** -** These routines must be called from the same thread in which -** the SQL function is running. -*/ -SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); -SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); - - -/* -** CAPI3REF: Constants Defining Special Destructor Behavior -** -** These are special values for the destructor that is passed in as the -** final argument to routines like [sqlite3_result_blob()]. ^If the destructor -** argument is SQLITE_STATIC, it means that the content pointer is constant -** and will never change. It does not need to be destroyed. ^The -** SQLITE_TRANSIENT value means that the content will likely change in -** the near future and that SQLite should make its own private copy of -** the content before returning. -** -** The typedef is necessary to work around problems in certain -** C++ compilers. See ticket #2191. -*/ -typedef void (*sqlite3_destructor_type)(void*); -#define SQLITE_STATIC ((sqlite3_destructor_type)0) -#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) - -/* -** CAPI3REF: Setting The Result Of An SQL Function -** -** These routines are used by the xFunc or xFinal callbacks that -** implement SQL functions and aggregates. See -** [sqlite3_create_function()] and [sqlite3_create_function16()] -** for additional information. -** -** These functions work very much like the [parameter binding] family of -** functions used to bind values to host parameters in prepared statements. -** Refer to the [SQL parameter] documentation for additional information. -** -** ^The sqlite3_result_blob() interface sets the result from -** an application-defined function to be the BLOB whose content is pointed -** to by the second parameter and which is N bytes long where N is the -** third parameter. -** -** ^The sqlite3_result_zeroblob() interfaces set the result of -** the application-defined function to be a BLOB containing all zero -** bytes and N bytes in size, where N is the value of the 2nd parameter. -** -** ^The sqlite3_result_double() interface sets the result from -** an application-defined function to be a floating point value specified -** by its 2nd argument. -** -** ^The sqlite3_result_error() and sqlite3_result_error16() functions -** cause the implemented SQL function to throw an exception. -** ^SQLite uses the string pointed to by the -** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() -** as the text of an error message. ^SQLite interprets the error -** message string from sqlite3_result_error() as UTF-8. ^SQLite -** interprets the string from sqlite3_result_error16() as UTF-16 in native -** byte order. ^If the third parameter to sqlite3_result_error() -** or sqlite3_result_error16() is negative then SQLite takes as the error -** message all text up through the first zero character. -** ^If the third parameter to sqlite3_result_error() or -** sqlite3_result_error16() is non-negative then SQLite takes that many -** bytes (not characters) from the 2nd parameter as the error message. -** ^The sqlite3_result_error() and sqlite3_result_error16() -** routines make a private copy of the error message text before -** they return. Hence, the calling function can deallocate or -** modify the text after they return without harm. -** ^The sqlite3_result_error_code() function changes the error code -** returned by SQLite as a result of an error in a function. ^By default, -** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() -** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. -** -** ^The sqlite3_result_toobig() interface causes SQLite to throw an error -** indicating that a string or BLOB is too long to represent. -** -** ^The sqlite3_result_nomem() interface causes SQLite to throw an error -** indicating that a memory allocation failed. -** -** ^The sqlite3_result_int() interface sets the return value -** of the application-defined function to be the 32-bit signed integer -** value given in the 2nd argument. -** ^The sqlite3_result_int64() interface sets the return value -** of the application-defined function to be the 64-bit signed integer -** value given in the 2nd argument. -** -** ^The sqlite3_result_null() interface sets the return value -** of the application-defined function to be NULL. -** -** ^The sqlite3_result_text(), sqlite3_result_text16(), -** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces -** set the return value of the application-defined function to be -** a text string which is represented as UTF-8, UTF-16 native byte order, -** UTF-16 little endian, or UTF-16 big endian, respectively. -** ^SQLite takes the text result from the application from -** the 2nd parameter of the sqlite3_result_text* interfaces. -** ^If the 3rd parameter to the sqlite3_result_text* interfaces -** is negative, then SQLite takes result text from the 2nd parameter -** through the first zero character. -** ^If the 3rd parameter to the sqlite3_result_text* interfaces -** is non-negative, then as many bytes (not characters) of the text -** pointed to by the 2nd parameter are taken as the application-defined -** function result. -** ^If the 4th parameter to the sqlite3_result_text* interfaces -** 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 -** finished using that result. -** ^If the 4th parameter to the sqlite3_result_text* interfaces or to -** 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 -** 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 -** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT -** then SQLite makes a copy of the result into space obtained from -** from [sqlite3_malloc()] before it returns. -** -** ^The sqlite3_result_value() interface sets the result of -** the application-defined function to be a copy the -** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The -** sqlite3_result_value() interface makes a copy of the [sqlite3_value] -** so that the [sqlite3_value] specified in the parameter may change or -** be deallocated after sqlite3_result_value() returns without harm. -** ^A [protected sqlite3_value] object may always be used where an -** [unprotected sqlite3_value] object is required, so either -** kind of [sqlite3_value] object can be used with this interface. -** -** If these routines are called from within the different thread -** than the one containing the application-defined function that received -** the [sqlite3_context] pointer, the results are undefined. -*/ -SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_double(sqlite3_context*, double); -SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); -SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); -SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); -SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); -SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); -SQLITE_API void sqlite3_result_int(sqlite3_context*, int); -SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); -SQLITE_API void sqlite3_result_null(sqlite3_context*); -SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); -SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); -SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); -SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); - -/* -** CAPI3REF: Define New Collating Sequences -** -** These functions are used to add new collation sequences to the -** [database connection] specified as the first argument. -** -** ^The name of the new collation sequence is specified as a UTF-8 string -** for sqlite3_create_collation() and sqlite3_create_collation_v2() -** and a UTF-16 string for sqlite3_create_collation16(). ^In all cases -** the name is passed as the second function argument. -** -** ^The third argument may be one of the constants [SQLITE_UTF8], -** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied -** routine expects to be passed pointers to strings encoded using UTF-8, -** UTF-16 little-endian, or UTF-16 big-endian, respectively. ^The -** third argument might also be [SQLITE_UTF16] to indicate that the routine -** expects pointers to be UTF-16 strings in the native byte order, or the -** argument can be [SQLITE_UTF16_ALIGNED] if the -** the routine expects pointers to 16-bit word aligned strings -** of UTF-16 in the native byte order. -** -** A pointer to the user supplied routine must be passed as the fifth -** argument. ^If it is NULL, this is the same as deleting the collation -** sequence (so that SQLite cannot call it anymore). -** ^Each time the application supplied function is invoked, it is passed -** as its first parameter a copy of the void* passed as the fourth argument -** to sqlite3_create_collation() or sqlite3_create_collation16(). -** -** ^The remaining arguments to the application-supplied routine are two strings, -** each represented by a (length, data) pair and encoded in the encoding -** that was passed as the third argument when the collation sequence was -** registered. The application defined collation routine should -** return negative, zero or positive if the first string is less than, -** equal to, or greater than the second string. i.e. (STRING1 - STRING2). -** -** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() -** except that it takes an extra argument which is a destructor for -** the collation. ^The destructor is called when the collation is -** destroyed and is passed a copy of the fourth parameter void* pointer -** of the sqlite3_create_collation_v2(). -** ^Collations are destroyed when they are overridden by later calls to the -** collation creation functions or when the [database connection] is closed -** using [sqlite3_close()]. -** -** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. -*/ -SQLITE_API int sqlite3_create_collation( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); -SQLITE_API int sqlite3_create_collation_v2( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*), - void(*xDestroy)(void*) -); -SQLITE_API int sqlite3_create_collation16( - sqlite3*, - const void *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); - -/* -** CAPI3REF: Collation Needed Callbacks -** -** ^To avoid having to register all collation sequences before a database -** can be used, a single callback function may be registered with the -** [database connection] to be invoked whenever an undefined collation -** sequence is required. -** -** ^If the function is registered using the sqlite3_collation_needed() API, -** then it is passed the names of undefined collation sequences as strings -** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, -** the names are passed as UTF-16 in machine native byte order. -** ^A call to either function replaces the existing collation-needed callback. -** -** ^(When the callback is invoked, the first argument passed is a copy -** of the second argument to sqlite3_collation_needed() or -** sqlite3_collation_needed16(). The second argument is the database -** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], -** or [SQLITE_UTF16LE], indicating the most desirable form of the collation -** sequence function required. The fourth parameter is the name of the -** required collation sequence.)^ -** -** The callback function should register the desired collation using -** [sqlite3_create_collation()], [sqlite3_create_collation16()], or -** [sqlite3_create_collation_v2()]. -*/ -SQLITE_API int sqlite3_collation_needed( - sqlite3*, - void*, - void(*)(void*,sqlite3*,int eTextRep,const char*) -); -SQLITE_API int sqlite3_collation_needed16( - sqlite3*, - void*, - void(*)(void*,sqlite3*,int eTextRep,const void*) -); - -#if SQLITE_HAS_CODEC -/* -** Specify the key for an encrypted database. This routine should be -** called right after sqlite3_open(). -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_key( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The key */ -); - -/* -** Change the key on an open database. If the current database is not -** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the -** database is decrypted. -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_rekey( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The new key */ -); - -/* -** Specify the activation key for a SEE database. Unless -** activated, none of the SEE routines will work. -*/ -SQLITE_API void sqlite3_activate_see( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -#ifdef SQLITE_ENABLE_CEROD -/* -** Specify the activation key for a CEROD database. Unless -** activated, none of the CEROD routines will work. -*/ -SQLITE_API void sqlite3_activate_cerod( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -/* -** CAPI3REF: Suspend Execution For A Short Time -** -** ^The sqlite3_sleep() function causes the current thread to suspend execution -** for at least a number of milliseconds specified in its parameter. -** -** ^If the operating system does not support sleep requests with -** millisecond time resolution, then the time will be rounded up to -** the nearest second. ^The number of milliseconds of sleep actually -** requested from the operating system is returned. -** -** ^SQLite implements this interface by calling the xSleep() -** method of the default [sqlite3_vfs] object. -*/ -SQLITE_API int sqlite3_sleep(int); - -/* -** CAPI3REF: Name Of The Folder Holding Temporary Files -** -** ^(If this global variable is made to point to a string which is -** the name of a folder (a.k.a. directory), then all temporary files -** created by SQLite when using a built-in [sqlite3_vfs | VFS] -** will be placed in that directory.)^ ^If this variable -** is a NULL pointer, then SQLite performs a search for an appropriate -** temporary file directory. -** -** It is not safe to read or modify this variable in more than one -** thread at a time. It is not safe to read or modify this variable -** if a [database connection] is being used at the same time in a separate -** thread. -** It is intended that this variable be set once -** as part of process initialization and before any SQLite interface -** routines have been called and that this variable remain unchanged -** thereafter. -** -** ^The [temp_store_directory pragma] may modify this variable and cause -** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, -** the [temp_store_directory pragma] always assumes that any string -** that this variable points to is held in memory obtained from -** [sqlite3_malloc] and the pragma may attempt to free that memory -** using [sqlite3_free]. -** Hence, if this variable is modified directly, either it should be -** made NULL or made to point to memory obtained from [sqlite3_malloc] -** or else the use of the [temp_store_directory pragma] should be avoided. -*/ -SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory; - -/* -** CAPI3REF: Test For Auto-Commit Mode -** KEYWORDS: {autocommit mode} -** -** ^The sqlite3_get_autocommit() interface returns non-zero or -** zero if the given database connection is or is not in autocommit mode, -** respectively. ^Autocommit mode is on by default. -** ^Autocommit mode is disabled by a [BEGIN] statement. -** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. -** -** If certain kinds of errors occur on a statement within a multi-statement -** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], -** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the -** transaction might be rolled back automatically. The only way to -** find out whether SQLite automatically rolled back the transaction after -** an error is to use this function. -** -** If another thread changes the autocommit status of the database -** connection while this routine is running, then the return value -** is undefined. -*/ -SQLITE_API int sqlite3_get_autocommit(sqlite3*); - -/* -** CAPI3REF: Find The Database Handle Of A Prepared Statement -** -** ^The sqlite3_db_handle interface returns the [database connection] handle -** to which a [prepared statement] belongs. ^The [database connection] -** returned by sqlite3_db_handle is the same [database connection] -** that was the first argument -** to the [sqlite3_prepare_v2()] call (or its variants) that was used to -** create the statement in the first place. -*/ -SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); - -/* -** CAPI3REF: Find the next prepared statement -** -** ^This interface returns a pointer to the next [prepared statement] after -** pStmt associated with the [database connection] pDb. ^If pStmt is NULL -** then this interface returns a pointer to the first prepared statement -** associated with the database connection pDb. ^If no prepared statement -** satisfies the conditions of this routine, it returns NULL. -** -** The [database connection] pointer D in a call to -** [sqlite3_next_stmt(D,S)] must refer to an open database -** connection and in particular must not be a NULL pointer. -*/ -SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Commit And Rollback Notification Callbacks -** -** ^The sqlite3_commit_hook() interface registers a callback -** function to be invoked whenever a transaction is [COMMIT | committed]. -** ^Any callback set by a previous call to sqlite3_commit_hook() -** for the same database connection is overridden. -** ^The sqlite3_rollback_hook() interface registers a callback -** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. -** ^Any callback set by a previous call to sqlite3_rollback_hook() -** for the same database connection is overridden. -** ^The pArg argument is passed through to the callback. -** ^If the callback on a commit hook function returns non-zero, -** then the commit is converted into a rollback. -** -** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions -** return the P argument from the previous call of the same function -** on the same [database connection] D, or NULL for -** the first call for each function on D. -** -** The callback implementation must not do anything that will modify -** the database connection that invoked the callback. Any actions -** to modify the database connection must be deferred until after the -** completion of the [sqlite3_step()] call that triggered the commit -** or rollback hook in the first place. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^Registering a NULL function disables the callback. -** -** ^When the commit hook callback routine returns zero, the [COMMIT] -** operation is allowed to continue normally. ^If the commit hook -** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. -** ^The rollback hook is invoked on a rollback that results from a commit -** hook returning non-zero, just as it would be with any other rollback. -** -** ^For the purposes of this API, a transaction is said to have been -** rolled back if an explicit "ROLLBACK" statement is executed, or -** an error or constraint causes an implicit rollback to occur. -** ^The rollback callback is not invoked if a transaction is -** automatically rolled back because the database connection is closed. -** ^The rollback callback is not invoked if a transaction is -** rolled back because a commit callback returned non-zero. -** -** See also the [sqlite3_update_hook()] interface. -*/ -SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); -SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); - -/* -** CAPI3REF: Data Change Notification Callbacks -** -** ^The sqlite3_update_hook() interface registers a callback function -** with the [database connection] identified by the first argument -** to be invoked whenever a row is updated, inserted or deleted. -** ^Any callback set by a previous call to this function -** for the same database connection is overridden. -** -** ^The second argument is a pointer to the function to invoke when a -** row is updated, inserted or deleted. -** ^The first argument to the callback is a copy of the third argument -** to sqlite3_update_hook(). -** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], -** or [SQLITE_UPDATE], depending on the operation that caused the callback -** to be invoked. -** ^The third and fourth arguments to the callback contain pointers to the -** database and table name containing the affected row. -** ^The final callback parameter is the [rowid] of the row. -** ^In the case of an update, this is the [rowid] after the update takes place. -** -** ^(The update hook is not invoked when internal system tables are -** modified (i.e. sqlite_master and sqlite_sequence).)^ -** -** ^In the current implementation, the update hook -** is not invoked when duplication rows are deleted because of an -** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook -** invoked when rows are deleted using the [truncate optimization]. -** The exceptions defined in this paragraph might change in a future -** release of SQLite. -** -** The update hook implementation must not do anything that will modify -** the database connection that invoked the update hook. Any actions -** to modify the database connection must be deferred until after the -** completion of the [sqlite3_step()] call that triggered the update hook. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^The sqlite3_update_hook(D,C,P) function -** returns the P argument from the previous call -** on the same [database connection] D, or NULL for -** the first call on D. -** -** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()] -** interfaces. -*/ -SQLITE_API void *sqlite3_update_hook( - sqlite3*, - void(*)(void *,int ,char const *,char const *,sqlite3_int64), - void* -); - -/* -** CAPI3REF: Enable Or Disable Shared Pager Cache -** KEYWORDS: {shared cache} -** -** ^(This routine enables or disables the sharing of the database cache -** and schema data structures between [database connection | connections] -** to the same database. Sharing is enabled if the argument is true -** and disabled if the argument is false.)^ -** -** ^Cache sharing is enabled and disabled for an entire process. -** This is a change as of SQLite version 3.5.0. In prior versions of SQLite, -** sharing was enabled or disabled for each thread separately. -** -** ^(The cache sharing mode set by this interface effects all subsequent -** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. -** Existing database connections continue use the sharing mode -** that was in effect at the time they were opened.)^ -** -** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled -** successfully. An [error code] is returned otherwise.)^ -** -** ^Shared cache is disabled by default. But this might change in -** future releases of SQLite. Applications that care about shared -** cache setting should set it explicitly. -** -** See Also: [SQLite Shared-Cache Mode] -*/ -SQLITE_API int sqlite3_enable_shared_cache(int); - -/* -** CAPI3REF: Attempt To Free Heap Memory -** -** ^The sqlite3_release_memory() interface attempts to free N bytes -** of heap memory by deallocating non-essential memory allocations -** held by the database library. Memory used to cache database -** pages to improve performance is an example of non-essential memory. -** ^sqlite3_release_memory() returns the number of bytes actually freed, -** which might be more or less than the amount requested. -*/ -SQLITE_API int sqlite3_release_memory(int); - -/* -** CAPI3REF: Impose A Limit On Heap Size -** -** ^The sqlite3_soft_heap_limit() interface places a "soft" limit -** on the amount of heap memory that may be allocated by SQLite. -** ^If an internal allocation is requested that would exceed the -** soft heap limit, [sqlite3_release_memory()] is invoked one or -** more times to free up some space before the allocation is performed. -** -** ^The limit is called "soft" because if [sqlite3_release_memory()] -** cannot free sufficient memory to prevent the limit from being exceeded, -** the memory is allocated anyway and the current operation proceeds. -** -** ^A negative or zero value for N means that there is no soft heap limit and -** [sqlite3_release_memory()] will only be called when memory is exhausted. -** ^The default value for the soft heap limit is zero. -** -** ^(SQLite makes a best effort to honor the soft heap limit. -** But if the soft heap limit cannot be honored, execution will -** continue without error or notification.)^ This is why the limit is -** called a "soft" limit. It is advisory only. -** -** Prior to SQLite version 3.5.0, this routine only constrained the memory -** allocated by a single thread - the same thread in which this routine -** runs. Beginning with SQLite version 3.5.0, the soft heap limit is -** applied to all threads. The value specified for the soft heap limit -** is an upper bound on the total memory allocation for all threads. In -** version 3.5.0 there is no mechanism for limiting the heap usage for -** individual threads. -*/ -SQLITE_API void sqlite3_soft_heap_limit(int); - -/* -** CAPI3REF: Extract Metadata About A Column Of A Table -** -** ^This routine returns metadata about a specific column of a specific -** database table accessible using the [database connection] handle -** passed as the first function argument. -** -** ^The column is identified by the second, third and fourth parameters to -** this function. ^The second parameter is either the name of the database -** (i.e. "main", "temp", or an attached database) containing the specified -** table or NULL. ^If it is NULL, then all attached databases are searched -** for the table using the same algorithm used by the database engine to -** resolve unqualified table references. -** -** ^The third and fourth parameters to this function are the table and column -** name of the desired column, respectively. Neither of these parameters -** may be NULL. -** -** ^Metadata is returned by writing to the memory locations passed as the 5th -** and subsequent parameters to this function. ^Any of these arguments may be -** NULL, in which case the corresponding element of metadata is omitted. -** -** ^(
-** -**
Parameter Output
Type 		Description -** -**
5th const char* Data type -**
6th const char* Name of default collation sequence -**
7th int True if column has a NOT NULL constraint -**
8th int True if column is part of the PRIMARY KEY -**
9th int True if column is [AUTOINCREMENT] -**
-**
)^ -** -** ^The memory pointed to by the character pointers returned for the -** declaration type and collation sequence is valid only until the next -** call to any SQLite API function. -** -** ^If the specified table is actually a view, an [error code] is returned. -** -** ^If the specified column is "rowid", "oid" or "_rowid_" and an -** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output -** parameters are set for the explicitly declared column. ^(If there is no -** explicitly declared [INTEGER PRIMARY KEY] column, then the output -** parameters are set as follows: -** -** 
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-**
)^ -** -** ^(This function may load one or more schemas from database files. If an -** error occurs during this process, or if the requested table or column -** cannot be found, an [error code] is returned and an error message left -** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ -** -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. -*/ -SQLITE_API int sqlite3_table_column_metadata( - sqlite3 *db, /* Connection handle */ - const char *zDbName, /* Database name or NULL */ - const char *zTableName, /* Table name */ - const char *zColumnName, /* Column name */ - char const **pzDataType, /* OUTPUT: Declared data type */ - char const **pzCollSeq, /* OUTPUT: Collation sequence name */ - int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ - int *pPrimaryKey, /* OUTPUT: True if column part of PK */ - int *pAutoinc /* OUTPUT: True if column is auto-increment */ -); - -/* -** CAPI3REF: Load An Extension -** -** ^This interface loads an SQLite extension library from the named file. -** -** ^The sqlite3_load_extension() interface attempts to load an -** SQLite extension library contained in the file zFile. -** -** ^The entry point is zProc. -** ^zProc may be 0, in which case the name of the entry point -** defaults to "sqlite3_extension_init". -** ^The sqlite3_load_extension() interface returns -** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. -** ^If an error occurs and pzErrMsg is not 0, then the -** [sqlite3_load_extension()] interface shall attempt to -** fill *pzErrMsg with error message text stored in memory -** obtained from [sqlite3_malloc()]. The calling function -** should free this memory by calling [sqlite3_free()]. -** -** ^Extension loading must be enabled using -** [sqlite3_enable_load_extension()] prior to calling this API, -** otherwise an error will be returned. -** -** See also the [load_extension() SQL function]. -*/ -SQLITE_API int sqlite3_load_extension( - sqlite3 *db, /* Load the extension into this database connection */ - const char *zFile, /* Name of the shared library containing extension */ - const char *zProc, /* Entry point. Derived from zFile if 0 */ - char **pzErrMsg /* Put error message here if not 0 */ -); - -/* -** CAPI3REF: Enable Or Disable Extension Loading -** -** ^So as not to open security holes in older applications that are -** unprepared to deal with extension loading, and as a means of disabling -** extension loading while evaluating user-entered SQL, the following API -** is provided to turn the [sqlite3_load_extension()] mechanism on and off. -** -** ^Extension loading is off by default. See ticket #1863. -** ^Call the sqlite3_enable_load_extension() routine with onoff==1 -** to turn extension loading on and call it with onoff==0 to turn -** it back off again. -*/ -SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); - -/* -** CAPI3REF: Automatically Load An Extensions -** -** ^This API can be invoked at program startup in order to register -** one or more statically linked extensions that will be available -** to all new [database connections]. -** -** ^(This routine stores a pointer to the extension entry point -** in an array that is obtained from [sqlite3_malloc()]. That memory -** is deallocated by [sqlite3_reset_auto_extension()].)^ -** -** ^This function registers an extension entry point that is -** automatically invoked whenever a new [database connection] -** is opened using [sqlite3_open()], [sqlite3_open16()], -** or [sqlite3_open_v2()]. -** ^Duplicate extensions are detected so calling this routine -** multiple times with the same extension is harmless. -** ^Automatic extensions apply across all threads. -*/ -SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); - -/* -** CAPI3REF: Reset Automatic Extension Loading -** -** ^(This function disables all previously registered automatic -** extensions. It undoes the effect of all prior -** [sqlite3_auto_extension()] calls.)^ -** -** ^This function disables automatic extensions in all threads. -*/ -SQLITE_API void sqlite3_reset_auto_extension(void); - -/* -****** EXPERIMENTAL - subject to change without notice ************** -** -** The interface to the virtual-table mechanism is currently considered -** to be experimental. The interface might change in incompatible ways. -** If this is a problem for you, do not use the interface at this time. -** -** When the virtual-table mechanism stabilizes, we will declare the -** interface fixed, support it indefinitely, and remove this comment. -*/ - -/* -** Structures used by the virtual table interface -*/ -typedef struct sqlite3_vtab sqlite3_vtab; -typedef struct sqlite3_index_info sqlite3_index_info; -typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; -typedef struct sqlite3_module sqlite3_module; - -/* -** CAPI3REF: Virtual Table Object -** KEYWORDS: sqlite3_module {virtual table module} -** EXPERIMENTAL -** -** This structure, sometimes called a a "virtual table module", -** defines the implementation of a [virtual tables]. -** This structure consists mostly of methods for the module. -** -** ^A virtual table module is created by filling in a persistent -** instance of this structure and passing a pointer to that instance -** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. -** ^The registration remains valid until it is replaced by a different -** module or until the [database connection] closes. The content -** of this structure must not change while it is registered with -** any database connection. -*/ -struct sqlite3_module { - int iVersion; - int (*xCreate)(sqlite3*, void *pAux, - int argc, const char *const*argv, - sqlite3_vtab **ppVTab, char**); - int (*xConnect)(sqlite3*, void *pAux, - int argc, const char *const*argv, - sqlite3_vtab **ppVTab, char**); - int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); - int (*xDisconnect)(sqlite3_vtab *pVTab); - int (*xDestroy)(sqlite3_vtab *pVTab); - int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); - int (*xClose)(sqlite3_vtab_cursor*); - int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, - int argc, sqlite3_value **argv); - int (*xNext)(sqlite3_vtab_cursor*); - int (*xEof)(sqlite3_vtab_cursor*); - int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); - int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); - int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); - int (*xBegin)(sqlite3_vtab *pVTab); - int (*xSync)(sqlite3_vtab *pVTab); - int (*xCommit)(sqlite3_vtab *pVTab); - int (*xRollback)(sqlite3_vtab *pVTab); - int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, - void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), - void **ppArg); - int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); -}; - -/* -** CAPI3REF: Virtual Table Indexing Information -** KEYWORDS: sqlite3_index_info -** EXPERIMENTAL -** -** The sqlite3_index_info structure and its substructures is used to -** pass information into and receive the reply from the [xBestIndex] -** method of a [virtual table module]. The fields under **Inputs** are the -** inputs to xBestIndex and are read-only. xBestIndex inserts its -** results into the **Outputs** fields. -** -** ^(The aConstraint[] array records WHERE clause constraints of the form: -** -** 
column OP expr
-** -** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is -** stored in aConstraint[].op.)^ ^(The index of the column is stored in -** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the -** expr on the right-hand side can be evaluated (and thus the constraint -** is usable) and false if it cannot.)^ -** -** ^The optimizer automatically inverts terms of the form "expr OP column" -** and makes other simplifications to the WHERE clause in an attempt to -** get as many WHERE clause terms into the form shown above as possible. -** ^The aConstraint[] array only reports WHERE clause terms that are -** relevant to the particular virtual table being queried. -** -** ^Information about the ORDER BY clause is stored in aOrderBy[]. -** ^Each term of aOrderBy records a column of the ORDER BY clause. -** -** The [xBestIndex] method must fill aConstraintUsage[] with information -** about what parameters to pass to xFilter. ^If argvIndex>0 then -** the right-hand side of the corresponding aConstraint[] is evaluated -** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit -** is true, then the constraint is assumed to be fully handled by the -** virtual table and is not checked again by SQLite.)^ -** -** ^The idxNum and idxPtr values are recorded and passed into the -** [xFilter] method. -** ^[sqlite3_free()] is used to free idxPtr if and only if -** needToFreeIdxPtr is true. -** -** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in -** the correct order to satisfy the ORDER BY clause so that no separate -** sorting step is required. -** -** ^The estimatedCost value is an estimate of the cost of doing the -** particular lookup. A full scan of a table with N entries should have -** a cost of N. A binary search of a table of N entries should have a -** cost of approximately log(N). -*/ -struct sqlite3_index_info { - /* Inputs */ - int nConstraint; /* Number of entries in aConstraint */ - struct sqlite3_index_constraint { - int iColumn; /* Column on left-hand side of constraint */ - unsigned char op; /* Constraint operator */ - unsigned char usable; /* True if this constraint is usable */ - int iTermOffset; /* Used internally - xBestIndex should ignore */ - } *aConstraint; /* Table of WHERE clause constraints */ - int nOrderBy; /* Number of terms in the ORDER BY clause */ - struct sqlite3_index_orderby { - int iColumn; /* Column number */ - unsigned char desc; /* True for DESC. False for ASC. */ - } *aOrderBy; /* The ORDER BY clause */ - /* Outputs */ - struct sqlite3_index_constraint_usage { - int argvIndex; /* if >0, constraint is part of argv to xFilter */ - unsigned char omit; /* Do not code a test for this constraint */ - } *aConstraintUsage; - int idxNum; /* Number used to identify the index */ - char *idxStr; /* String, possibly obtained from sqlite3_malloc */ - int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ - int orderByConsumed; /* True if output is already ordered */ - double estimatedCost; /* Estimated cost of using this index */ -}; -#define SQLITE_INDEX_CONSTRAINT_EQ 2 -#define SQLITE_INDEX_CONSTRAINT_GT 4 -#define SQLITE_INDEX_CONSTRAINT_LE 8 -#define SQLITE_INDEX_CONSTRAINT_LT 16 -#define SQLITE_INDEX_CONSTRAINT_GE 32 -#define SQLITE_INDEX_CONSTRAINT_MATCH 64 - -/* -** CAPI3REF: Register A Virtual Table Implementation -** EXPERIMENTAL -** -** ^These routines are used to register a new [virtual table module] name. -** ^Module names must be registered before -** creating a new [virtual table] using the module and before using a -** preexisting [virtual table] for the module. -** -** ^The module name is registered on the [database connection] specified -** by the first parameter. ^The name of the module is given by the -** second parameter. ^The third parameter is a pointer to -** the implementation of the [virtual table module]. ^The fourth -** parameter is an arbitrary client data pointer that is passed through -** into the [xCreate] and [xConnect] methods of the virtual table module -** when a new virtual table is be being created or reinitialized. -** -** ^The sqlite3_create_module_v2() interface has a fifth parameter which -** is a pointer to a destructor for the pClientData. ^SQLite will -** invoke the destructor function (if it is not NULL) when SQLite -** no longer needs the pClientData pointer. ^The sqlite3_create_module() -** interface is equivalent to sqlite3_create_module_v2() with a NULL -** destructor. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module( - sqlite3 *db, /* SQLite connection to register module with */ - const char *zName, /* Name of the module */ - const sqlite3_module *p, /* Methods for the module */ - void *pClientData /* Client data for xCreate/xConnect */ -); -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module_v2( - sqlite3 *db, /* SQLite connection to register module with */ - const char *zName, /* Name of the module */ - const sqlite3_module *p, /* Methods for the module */ - void *pClientData, /* Client data for xCreate/xConnect */ - void(*xDestroy)(void*) /* Module destructor function */ -); - -/* -** CAPI3REF: Virtual Table Instance Object -** KEYWORDS: sqlite3_vtab -** EXPERIMENTAL -** -** Every [virtual table module] implementation uses a subclass -** of this object to describe a particular instance -** of the [virtual table]. Each subclass will -** be tailored to the specific needs of the module implementation. -** The purpose of this superclass is to define certain fields that are -** common to all module implementations. -** -** ^Virtual tables methods can set an error message by assigning a -** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should -** take care that any prior string is freed by a call to [sqlite3_free()] -** prior to assigning a new string to zErrMsg. ^After the error message -** is delivered up to the client application, the string will be automatically -** freed by sqlite3_free() and the zErrMsg field will be zeroed. -*/ -struct sqlite3_vtab { - const sqlite3_module *pModule; /* The module for this virtual table */ - int nRef; /* NO LONGER USED */ - char *zErrMsg; /* Error message from sqlite3_mprintf() */ - /* Virtual table implementations will typically add additional fields */ -}; - -/* -** CAPI3REF: Virtual Table Cursor Object -** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} -** EXPERIMENTAL -** -** Every [virtual table module] implementation uses a subclass of the -** following structure to describe cursors that point into the -** [virtual table] and are used -** to loop through the virtual table. Cursors are created using the -** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed -** by the [sqlite3_module.xClose | xClose] method. Cursors are used -** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods -** of the module. Each module implementation will define -** the content of a cursor structure to suit its own needs. -** -** This superclass exists in order to define fields of the cursor that -** are common to all implementations. -*/ -struct sqlite3_vtab_cursor { - sqlite3_vtab *pVtab; /* Virtual table of this cursor */ - /* Virtual table implementations will typically add additional fields */ -}; - -/* -** CAPI3REF: Declare The Schema Of A Virtual Table -** EXPERIMENTAL -** -** ^The [xCreate] and [xConnect] methods of a -** [virtual table module] call this interface -** to declare the format (the names and datatypes of the columns) of -** the virtual tables they implement. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL); - -/* -** CAPI3REF: Overload A Function For A Virtual Table -** EXPERIMENTAL -** -** ^(Virtual tables can provide alternative implementations of functions -** using the [xFindFunction] method of the [virtual table module]. -** But global versions of those functions -** must exist in order to be overloaded.)^ -** -** ^(This API makes sure a global version of a function with a particular -** name and number of parameters exists. If no such function exists -** before this API is called, a new function is created.)^ ^The implementation -** of the new function always causes an exception to be thrown. So -** the new function is not good for anything by itself. Its only -** purpose is to be a placeholder function that can be overloaded -** by a [virtual table]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); - -/* -** The interface to the virtual-table mechanism defined above (back up -** to a comment remarkably similar to this one) is currently considered -** to be experimental. The interface might change in incompatible ways. -** If this is a problem for you, do not use the interface at this time. -** -** When the virtual-table mechanism stabilizes, we will declare the -** interface fixed, support it indefinitely, and remove this comment. -** -****** EXPERIMENTAL - subject to change without notice ************** -*/ - -/* -** CAPI3REF: A Handle To An Open BLOB -** KEYWORDS: {BLOB handle} {BLOB handles} -** -** An instance of this object represents an open BLOB on which -** [sqlite3_blob_open | incremental BLOB I/O] can be performed. -** ^Objects of this type are created by [sqlite3_blob_open()] -** and destroyed by [sqlite3_blob_close()]. -** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces -** can be used to read or write small subsections of the BLOB. -** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. -*/ -typedef struct sqlite3_blob sqlite3_blob; - -/* -** CAPI3REF: Open A BLOB For Incremental I/O -** -** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located -** in row iRow, column zColumn, table zTable in database zDb; -** in other words, the same BLOB that would be selected by: -** -** 
-**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
-**
)^ -** -** ^If the flags parameter is non-zero, then the BLOB is opened for read -** and write access. ^If it is zero, the BLOB is opened for read access. -** ^It is not possible to open a column that is part of an index or primary -** key for writing. ^If [foreign key constraints] are enabled, it is -** not possible to open a column that is part of a [child key] for writing. -** -** ^Note that the database name is not the filename that contains -** the database but rather the symbolic name of the database that -** appears after the AS keyword when the database is connected using [ATTACH]. -** ^For the main database file, the database name is "main". -** ^For TEMP tables, the database name is "temp". -** -** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written -** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set -** to be a null pointer.)^ -** ^This function sets the [database connection] error code and message -** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related -** functions. ^Note that the *ppBlob variable is always initialized in a -** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob -** regardless of the success or failure of this routine. -** -** ^(If the row that a BLOB handle points to is modified by an -** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects -** then the BLOB handle is marked as "expired". -** This is true if any column of the row is changed, even a column -** other than the one the BLOB handle is open on.)^ -** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for -** a expired BLOB handle fail with an return code of [SQLITE_ABORT]. -** ^(Changes written into a BLOB prior to the BLOB expiring are not -** rolled back by the expiration of the BLOB. Such changes will eventually -** commit if the transaction continues to completion.)^ -** -** ^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 -** interface. Use the [UPDATE] SQL command to change the size of a -** blob. -** -** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces -** and the built-in [zeroblob] SQL function can be used, if desired, -** to create an empty, zero-filled blob in which to read or write using -** this interface. -** -** To avoid a resource leak, every open [BLOB handle] should eventually -** be released by a call to [sqlite3_blob_close()]. -*/ -SQLITE_API int sqlite3_blob_open( - sqlite3*, - const char *zDb, - const char *zTable, - const char *zColumn, - sqlite3_int64 iRow, - int flags, - sqlite3_blob **ppBlob -); - -/* -** CAPI3REF: Close A BLOB Handle -** -** ^Closes an open [BLOB handle]. -** -** ^Closing a BLOB shall cause the current transaction to commit -** if there are no other BLOBs, no pending prepared statements, and the -** database connection is in [autocommit mode]. -** ^If any writes were made to the BLOB, they might be held in cache -** until the close operation if they will fit. -** -** ^(Closing the BLOB often forces the changes -** out to disk and so if any I/O errors occur, they will likely occur -** at the time when the BLOB is closed. Any errors that occur during -** closing are reported as a non-zero return value.)^ -** -** ^(The BLOB is closed unconditionally. Even if this routine returns -** an error code, the BLOB is still closed.)^ -** -** ^Calling this routine with a null pointer (such as would be returned -** by a failed call to [sqlite3_blob_open()]) is a harmless no-op. -*/ -SQLITE_API int sqlite3_blob_close(sqlite3_blob *); - -/* -** CAPI3REF: Return The Size Of An Open BLOB -** -** ^Returns the size in bytes of the BLOB accessible via the -** successfully opened [BLOB handle] in its only argument. ^The -** incremental blob I/O routines can only read or overwriting existing -** blob content; they cannot change the size of a blob. -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -*/ -SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); - -/* -** CAPI3REF: Read Data From A BLOB Incrementally -** -** ^(This function is used to read data from an open [BLOB handle] into a -** caller-supplied buffer. N bytes of data are copied into buffer Z -** from the open BLOB, starting at offset iOffset.)^ -** -** ^If offset iOffset is less than N bytes from the end of the BLOB, -** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is -** less than zero, [SQLITE_ERROR] is returned and no data is read. -** ^The size of the blob (and hence the maximum value of N+iOffset) -** can be determined using the [sqlite3_blob_bytes()] interface. -** -** ^An attempt to read from an expired [BLOB handle] fails with an -** error code of [SQLITE_ABORT]. -** -** ^(On success, sqlite3_blob_read() returns SQLITE_OK. -** Otherwise, an [error code] or an [extended error code] is returned.)^ -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -** -** See also: [sqlite3_blob_write()]. -*/ -SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); - -/* -** CAPI3REF: Write Data Into A BLOB Incrementally -** -** ^This function is used to write data into an open [BLOB handle] from a -** caller-supplied buffer. ^N bytes of data are copied from the buffer Z -** into the open BLOB, starting at offset iOffset. -** -** ^If the [BLOB handle] passed as the first argument was not opened for -** writing (the flags parameter to [sqlite3_blob_open()] was zero), -** this function returns [SQLITE_READONLY]. -** -** ^This function may only modify the contents of the BLOB; it is -** not possible to increase the size of a BLOB using this API. -** ^If offset iOffset is less than N bytes from the end of the BLOB, -** [SQLITE_ERROR] is returned and no data is written. ^If N is -** less than zero [SQLITE_ERROR] is returned and no data is written. -** The size of the BLOB (and hence the maximum value of N+iOffset) -** can be determined using the [sqlite3_blob_bytes()] interface. -** -** ^An attempt to write to an expired [BLOB handle] fails with an -** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred -** before the [BLOB handle] expired are not rolled back by the -** expiration of the handle, though of course those changes might -** have been overwritten by the statement that expired the BLOB handle -** or by other independent statements. -** -** ^(On success, sqlite3_blob_write() returns SQLITE_OK. -** Otherwise, an [error code] or an [extended error code] is returned.)^ -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -** -** See also: [sqlite3_blob_read()]. -*/ -SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); - -/* -** CAPI3REF: Virtual File System Objects -** -** A virtual filesystem (VFS) is an [sqlite3_vfs] object -** that SQLite uses to interact -** with the underlying operating system. Most SQLite builds come with a -** single default VFS that is appropriate for the host computer. -** New VFSes can be registered and existing VFSes can be unregistered. -** The following interfaces are provided. -** -** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. -** ^Names are case sensitive. -** ^Names are zero-terminated UTF-8 strings. -** ^If there is no match, a NULL pointer is returned. -** ^If zVfsName is NULL then the default VFS is returned. -** -** ^New VFSes are registered with sqlite3_vfs_register(). -** ^Each new VFS becomes the default VFS if the makeDflt flag is set. -** ^The same VFS can be registered multiple times without injury. -** ^To make an existing VFS into the default VFS, register it again -** with the makeDflt flag set. If two different VFSes with the -** same name are registered, the behavior is undefined. If a -** VFS is registered with a name that is NULL or an empty string, -** then the behavior is undefined. -** -** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. -** ^(If the default VFS is unregistered, another VFS is chosen as -** the default. The choice for the new VFS is arbitrary.)^ -*/ -SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); -SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); -SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); - -/* -** CAPI3REF: Mutexes -** -** The SQLite core uses these routines for thread -** synchronization. Though they are intended for internal -** use by SQLite, code that links against SQLite is -** permitted to use any of these routines. -** -** The SQLite source code contains multiple implementations -** of these mutex routines. An appropriate implementation -** is selected automatically at compile-time. ^(The following -** implementations are available in the SQLite core: -** -**
    -**
  • SQLITE_MUTEX_OS2 -**
  • SQLITE_MUTEX_PTHREAD -**
  • SQLITE_MUTEX_W32 -**
  • SQLITE_MUTEX_NOOP -**
)^ -** -** ^The SQLITE_MUTEX_NOOP implementation is a set of routines -** that does no real locking and is appropriate for use in -** a single-threaded application. ^The SQLITE_MUTEX_OS2, -** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations -** are appropriate for use on OS/2, Unix, and Windows. -** -** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor -** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex -** implementation is included with the library. In this case the -** application must supply a custom mutex implementation using the -** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function -** before calling sqlite3_initialize() or any other public sqlite3_ -** function that calls sqlite3_initialize().)^ -** -** ^The sqlite3_mutex_alloc() routine allocates a new -** mutex and returns a pointer to it. ^If it returns NULL -** that means that a mutex could not be allocated. ^SQLite -** will unwind its stack and return an error. ^(The argument -** to sqlite3_mutex_alloc() is one of these integer constants: -** -**
    -**
  • SQLITE_MUTEX_FAST -**
  • SQLITE_MUTEX_RECURSIVE -**
  • SQLITE_MUTEX_STATIC_MASTER -**
  • SQLITE_MUTEX_STATIC_MEM -**
  • SQLITE_MUTEX_STATIC_MEM2 -**
  • SQLITE_MUTEX_STATIC_PRNG -**
  • SQLITE_MUTEX_STATIC_LRU -**
  • SQLITE_MUTEX_STATIC_LRU2 -**
)^ -** -** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) -** cause sqlite3_mutex_alloc() to create -** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE -** is used but not necessarily so when SQLITE_MUTEX_FAST is used. -** The mutex implementation does not need to make a distinction -** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does -** not want to. ^SQLite will only request a recursive mutex in -** cases where it really needs one. ^If a faster non-recursive mutex -** implementation is available on the host platform, the mutex subsystem -** might return such a mutex in response to SQLITE_MUTEX_FAST. -** -** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other -** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return -** a pointer to a static preexisting mutex. ^Six static mutexes are -** used by the current version of SQLite. Future versions of SQLite -** may add additional static mutexes. Static mutexes are for internal -** use by SQLite only. Applications that use SQLite mutexes should -** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or -** SQLITE_MUTEX_RECURSIVE. -** -** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST -** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() -** returns a different mutex on every call. ^But for the static -** mutex types, the same mutex is returned on every call that has -** the same type number. -** -** ^The sqlite3_mutex_free() routine deallocates a previously -** allocated dynamic mutex. ^SQLite is careful to deallocate every -** dynamic mutex that it allocates. The dynamic mutexes must not be in -** use when they are deallocated. Attempting to deallocate a static -** mutex results in undefined behavior. ^SQLite never deallocates -** a static mutex. -** -** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt -** to enter a mutex. ^If another thread is already within the mutex, -** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return -** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] -** upon successful entry. ^(Mutexes created using -** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. -** In such cases the, -** mutex must be exited an equal number of times before another thread -** can enter.)^ ^(If the same thread tries to enter any other -** kind of mutex more than once, the behavior is undefined. -** SQLite will never exhibit -** such behavior in its own use of mutexes.)^ -** -** ^(Some systems (for example, Windows 95) do not support the operation -** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() -** will always return SQLITE_BUSY. The SQLite core only ever uses -** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^ -** -** ^The sqlite3_mutex_leave() routine exits a mutex that was -** previously entered by the same thread. ^(The behavior -** is undefined if the mutex is not currently entered by the -** calling thread or is not currently allocated. SQLite will -** never do either.)^ -** -** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or -** sqlite3_mutex_leave() is a NULL pointer, then all three routines -** behave as no-ops. -** -** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. -*/ -SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); -SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); -SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); -SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); -SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); - -/* -** CAPI3REF: Mutex Methods Object -** EXPERIMENTAL -** -** An instance of this structure defines the low-level routines -** used to allocate and use mutexes. -** -** Usually, the default mutex implementations provided by SQLite are -** sufficient, however the user has the option of substituting a custom -** implementation for specialized deployments or systems for which SQLite -** does not provide a suitable implementation. In this case, the user -** creates and populates an instance of this structure to pass -** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. -** Additionally, an instance of this structure can be used as an -** output variable when querying the system for the current mutex -** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. -** -** ^The xMutexInit method defined by this structure is invoked as -** part of system initialization by the sqlite3_initialize() function. -** ^The xMutexInit routine is calle by SQLite exactly once for each -** effective call to [sqlite3_initialize()]. -** -** ^The xMutexEnd method defined by this structure is invoked as -** part of system shutdown by the sqlite3_shutdown() function. The -** implementation of this method is expected to release all outstanding -** resources obtained by the mutex methods implementation, especially -** those obtained by the xMutexInit method. ^The xMutexEnd() -** interface is invoked exactly once for each call to [sqlite3_shutdown()]. -** -** ^(The remaining seven methods defined by this structure (xMutexAlloc, -** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and -** xMutexNotheld) implement the following interfaces (respectively): -** -**
    -**
  • [sqlite3_mutex_alloc()]
    • -**
  • [sqlite3_mutex_free()]
    • -**
  • [sqlite3_mutex_enter()]
    • -**
  • [sqlite3_mutex_try()]
    • -**
  • [sqlite3_mutex_leave()]
    • -**
  • [sqlite3_mutex_held()]
    • -**
  • [sqlite3_mutex_notheld()]
    • -**
)^ -** -** The only difference is that the public sqlite3_XXX functions enumerated -** above silently ignore any invocations that pass a NULL pointer instead -** of a valid mutex handle. The implementations of the methods defined -** by this structure are not required to handle this case, the results -** 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 -** 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; -struct sqlite3_mutex_methods { - int (*xMutexInit)(void); - int (*xMutexEnd)(void); - sqlite3_mutex *(*xMutexAlloc)(int); - void (*xMutexFree)(sqlite3_mutex *); - void (*xMutexEnter)(sqlite3_mutex *); - int (*xMutexTry)(sqlite3_mutex *); - void (*xMutexLeave)(sqlite3_mutex *); - int (*xMutexHeld)(sqlite3_mutex *); - int (*xMutexNotheld)(sqlite3_mutex *); -}; - -/* -** CAPI3REF: Mutex Verification Routines -** -** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines -** are intended for use inside assert() statements. ^The SQLite core -** never uses these routines except inside an assert() and applications -** are advised to follow the lead of the core. ^The SQLite core only -** provides implementations for these routines when it is compiled -** with the SQLITE_DEBUG flag. ^External mutex implementations -** are only required to provide these routines if SQLITE_DEBUG is -** defined and if NDEBUG is not defined. -** -** ^These routines should return true if the mutex in their argument -** is held or not held, respectively, by the calling thread. -** -** ^The implementation is not required to provided versions of these -** routines that actually work. If the implementation does not provide working -** versions of these routines, it should at least provide stubs that always -** return true so that one does not get spurious assertion failures. -** -** ^If the argument to sqlite3_mutex_held() is a NULL pointer then -** the routine should return 1. This seems counter-intuitive since -** clearly the mutex cannot be held if it does not exist. But the -** the reason the mutex does not exist is because the build is not -** using mutexes. And we do not want the assert() containing the -** call to sqlite3_mutex_held() to fail, so a non-zero return is -** the appropriate thing to do. ^The sqlite3_mutex_notheld() -** interface should also return 1 when given a NULL pointer. -*/ -#ifndef NDEBUG -SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); -SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); -#endif - -/* -** CAPI3REF: Mutex Types -** -** The [sqlite3_mutex_alloc()] interface takes a single argument -** which is one of these integer constants. -** -** The set of static mutexes may change from one SQLite release to the -** next. Applications that override the built-in mutex logic must be -** prepared to accommodate additional static mutexes. -*/ -#define SQLITE_MUTEX_FAST 0 -#define SQLITE_MUTEX_RECURSIVE 1 -#define SQLITE_MUTEX_STATIC_MASTER 2 -#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ -#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ -#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ -#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ -#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ -#define SQLITE_MUTEX_STATIC_LRU2 7 /* lru page list */ - -/* -** CAPI3REF: Retrieve the mutex for a database connection -** -** ^This interface returns a pointer the [sqlite3_mutex] object that -** serializes access to the [database connection] given in the argument -** when the [threading mode] is Serialized. -** ^If the [threading mode] is Single-thread or Multi-thread then this -** routine returns a NULL pointer. -*/ -SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); - -/* -** CAPI3REF: Low-Level Control Of Database Files -** -** ^The [sqlite3_file_control()] interface makes a direct call to the -** xFileControl method for the [sqlite3_io_methods] object associated -** with a particular database identified by the second argument. ^The -** name of the database "main" for the main database or "temp" for the -** TEMP database, or the name that appears after the AS keyword for -** databases that are added using the [ATTACH] SQL command. -** ^A NULL pointer can be used in place of "main" to refer to the -** main database file. -** ^The third and fourth parameters to this routine -** are passed directly through to the second and third parameters of -** the xFileControl method. ^The return value of the xFileControl -** method becomes the return value of this routine. -** -** ^If the second parameter (zDbName) does not match the name of any -** open database file, then SQLITE_ERROR is returned. ^This error -** code is not remembered and will not be recalled by [sqlite3_errcode()] -** or [sqlite3_errmsg()]. The underlying xFileControl method might -** also return SQLITE_ERROR. There is no way to distinguish between -** an incorrect zDbName and an SQLITE_ERROR return from the underlying -** xFileControl method. -** -** See also: [SQLITE_FCNTL_LOCKSTATE] -*/ -SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); - -/* -** CAPI3REF: Testing Interface -** -** ^The sqlite3_test_control() interface is used to read out internal -** state of SQLite and to inject faults into SQLite for testing -** purposes. ^The first parameter is an operation code that determines -** the number, meaning, and operation of all subsequent parameters. -** -** This interface is not for use by applications. It exists solely -** for verifying the correct operation of the SQLite library. Depending -** on how the SQLite library is compiled, this interface might not exist. -** -** The details of the operation codes, their meanings, the parameters -** they take, and what they do are all subject to change without notice. -** Unlike most of the SQLite API, this function is not guaranteed to -** operate consistently from one release to the next. -*/ -SQLITE_API int sqlite3_test_control(int op, ...); - -/* -** CAPI3REF: Testing Interface Operation Codes -** -** These constants are the valid operation code parameters used -** as the first argument to [sqlite3_test_control()]. -** -** These parameters and their meanings are subject to change -** without notice. These values are for testing purposes only. -** Applications should not use any of these parameters or the -** [sqlite3_test_control()] interface. -*/ -#define SQLITE_TESTCTRL_FIRST 5 -#define SQLITE_TESTCTRL_PRNG_SAVE 5 -#define SQLITE_TESTCTRL_PRNG_RESTORE 6 -#define SQLITE_TESTCTRL_PRNG_RESET 7 -#define SQLITE_TESTCTRL_BITVEC_TEST 8 -#define SQLITE_TESTCTRL_FAULT_INSTALL 9 -#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 -#define SQLITE_TESTCTRL_PENDING_BYTE 11 -#define SQLITE_TESTCTRL_ASSERT 12 -#define SQLITE_TESTCTRL_ALWAYS 13 -#define SQLITE_TESTCTRL_RESERVE 14 -#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 -#define SQLITE_TESTCTRL_ISKEYWORD 16 -#define SQLITE_TESTCTRL_LAST 16 - -/* -** CAPI3REF: SQLite Runtime Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about the preformance of SQLite, and optionally to reset various -** highwater marks. ^The first argument is an integer code for -** the specific parameter to measure. ^(Recognized integer codes -** are of the form [SQLITE_STATUS_MEMORY_USED | SQLITE_STATUS_...].)^ -** ^The current value of the parameter is returned into *pCurrent. -** ^The highest recorded value is returned in *pHighwater. ^If the -** resetFlag is true, then the highest record value is reset after -** *pHighwater is written. ^(Some parameters do not record the highest -** value. For those parameters -** nothing is written into *pHighwater and the resetFlag is ignored.)^ -** ^(Other parameters record only the highwater mark and not the current -** value. For these latter parameters nothing is written into *pCurrent.)^ -** -** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a -** non-zero [error code] on failure. -** -** This routine is threadsafe but is not atomic. This routine can be -** called while other threads are running the same or different SQLite -** interfaces. However the values returned in *pCurrent and -** *pHighwater reflect the status of SQLite at different points in time -** and it is possible that another thread might change the parameter -** in between the times when *pCurrent and *pHighwater are written. -** -** See also: [sqlite3_db_status()] -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); - - -/* -** CAPI3REF: Status Parameters -** EXPERIMENTAL -** -** These integer constants designate various run-time status parameters -** that can be returned by [sqlite3_status()]. -** -**
-** ^(
SQLITE_STATUS_MEMORY_USED
-**
This parameter is the current amount of memory checked out -** using [sqlite3_malloc()], either directly or indirectly. The -** figure includes calls made to [sqlite3_malloc()] by the application -** and internal memory usage by the SQLite library. Scratch memory -** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache -** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in -** this parameter. The amount returned is the sum of the allocation -** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ -** -** ^(
SQLITE_STATUS_MALLOC_SIZE
-**
This parameter records the largest memory allocation request -** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their -** internal equivalents). Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_USED
-**
This parameter returns the number of pages used out of the -** [pagecache memory allocator] that was configured using -** [SQLITE_CONFIG_PAGECACHE]. The -** value returned is in pages, not in bytes.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
-**
This parameter returns the number of bytes of page cache -** allocation which could not be statisfied by the [SQLITE_CONFIG_PAGECACHE] -** buffer and where forced to overflow to [sqlite3_malloc()]. The -** returned value includes allocations that overflowed because they -** where too large (they were larger than the "sz" parameter to -** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because -** no space was left in the page cache.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_SIZE
-**
This parameter records the largest memory allocation request -** handed to [pagecache memory allocator]. Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_USED
-**
This parameter returns the number of allocations used out of the -** [scratch memory allocator] configured using -** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not -** in bytes. Since a single thread may only have one scratch allocation -** outstanding at time, this parameter also reports the number of threads -** using scratch memory at the same time.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
-**
This parameter returns the number of bytes of scratch memory -** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH] -** buffer and where forced to overflow to [sqlite3_malloc()]. The values -** returned include overflows because the requested allocation was too -** larger (that is, because the requested allocation was larger than the -** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer -** slots were available. -**
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_SIZE
-**
This parameter records the largest memory allocation request -** handed to [scratch memory allocator]. Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_PARSER_STACK
-**
This parameter records the deepest parser stack. It is only -** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ -**
-** -** New status parameters may be added from time to time. -*/ -#define SQLITE_STATUS_MEMORY_USED 0 -#define SQLITE_STATUS_PAGECACHE_USED 1 -#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 -#define SQLITE_STATUS_SCRATCH_USED 3 -#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 -#define SQLITE_STATUS_MALLOC_SIZE 5 -#define SQLITE_STATUS_PARSER_STACK 6 -#define SQLITE_STATUS_PAGECACHE_SIZE 7 -#define SQLITE_STATUS_SCRATCH_SIZE 8 - -/* -** CAPI3REF: Database Connection Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about a single [database connection]. ^The first argument is the -** database connection object to be interrogated. ^The second argument -** is the parameter to interrogate. ^Currently, the only allowed value -** for the second parameter is [SQLITE_DBSTATUS_LOOKASIDE_USED]. -** Additional options will likely appear in future releases of SQLite. -** -** ^The current value of the requested parameter is written into *pCur -** and the highest instantaneous value is written into *pHiwtr. ^If -** the resetFlg is true, then the highest instantaneous value is -** reset back down to the current value. -** -** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); - -/* -** CAPI3REF: Status Parameters for database connections -** EXPERIMENTAL -** -** 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. -** -**
-** ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
-**
This parameter returns the number of lookaside memory slots currently -** checked out.
)^ -**
-*/ -#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 - - -/* -** CAPI3REF: Prepared Statement Status -** EXPERIMENTAL -** -** ^(Each prepared statement maintains various -** [SQLITE_STMTSTATUS_SORT | counters] that measure the number -** of times it has performed specific operations.)^ These counters can -** be used to monitor the performance characteristics of the prepared -** statements. For example, if the number of table steps greatly exceeds -** the number of table searches or result rows, that would tend to indicate -** that the prepared statement is using a full table scan rather than -** an index. -** -** ^(This interface is used to retrieve and reset counter values from -** a [prepared statement]. The first argument is the prepared statement -** object to be interrogated. The second argument -** is an integer code for a specific [SQLITE_STMTSTATUS_SORT | counter] -** to be interrogated.)^ -** ^The current value of the requested counter is returned. -** ^If the resetFlg is true, then the counter is reset to zero after this -** interface call returns. -** -** See also: [sqlite3_status()] and [sqlite3_db_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); - -/* -** CAPI3REF: Status Parameters for prepared statements -** EXPERIMENTAL -** -** These preprocessor macros define integer codes that name counter -** values associated with the [sqlite3_stmt_status()] interface. -** The meanings of the various counters are as follows: -** -**
-**
SQLITE_STMTSTATUS_FULLSCAN_STEP
-**
^This is the number of times that SQLite has stepped forward in -** a table as part of a full table scan. Large numbers for this counter -** may indicate opportunities for performance improvement through -** careful use of indices.
-** -**
SQLITE_STMTSTATUS_SORT
-**
^This is the number of sort operations that have occurred. -** A non-zero value in this counter may indicate an opportunity to -** improvement performance through careful use of indices.
-** -**
-*/ -#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 -#define SQLITE_STMTSTATUS_SORT 2 - -/* -** CAPI3REF: Custom Page Cache Object -** EXPERIMENTAL -** -** The sqlite3_pcache type is opaque. It is implemented by -** the pluggable module. The SQLite core has no knowledge of -** its size or internal structure and never deals with the -** sqlite3_pcache object except by holding and passing pointers -** to the object. -** -** See [sqlite3_pcache_methods] for additional information. -*/ -typedef struct sqlite3_pcache sqlite3_pcache; - -/* -** CAPI3REF: Application Defined Page Cache. -** KEYWORDS: {page cache} -** EXPERIMENTAL -** -** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can -** register an alternative page cache implementation by passing in an -** 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 -** from, or ready to be written to, the database file. By implementing a -** custom page cache using this API, an application can control more -** precisely the amount of memory consumed by SQLite, the way in which -** that memory is allocated and released, and the policies used to -** determine exactly which parts of a database file are cached and for -** how long. -** -** ^(The contents of the sqlite3_pcache_methods structure are copied to an -** 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()] -** (usually only once during the lifetime of the process). ^(The xInit() -** method is passed a copy of the sqlite3_pcache_methods.pArg value.)^ -** ^The xInit() method can set up up global structures and/or any mutexes -** required by the custom page cache implementation. -** -** ^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 -** be allocated by the cache. ^szPage will not be a power of two. ^szPage -** will the page size of the database file that is to be cached plus an -** 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 -** does not have to do anything special based with the value of bPurgeable; -** 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 -** suggested maximum cache-size (number of pages stored by) the cache -** instance passed as the first argument. This is the value configured using -** the SQLite "[PRAGMA cache_size]" command.)^ ^As with the bPurgeable -** parameter, the implementation is not required to do anything with this -** value; it is advisory only. -** -** ^The xPagecount() method should return the number of pages currently -** stored in the cache. -** -** ^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 -** 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 -** is considered to be "pinned". -** -** ^If the requested page is already in the page cache, then the page cache -** implementation must return a pointer to the page buffer with its content -** intact. ^(If the requested page is not already in the cache, then the -** behavior of the cache implementation is determined by the value of the -** createFlag parameter passed to xFetch, according to the following table: -** -** -**
createFlag Behaviour when page is not already in cache -**
0 Do not allocate a new page. Return NULL. -**
1 Allocate a new page if it easy and convenient to do so. -** Otherwise return NULL. -**
2 Make every effort to allocate a new page. Only return -** NULL if allocating a new page is effectively impossible. -**
)^ -** -** 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 -** 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 -** 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 -** zero, then the page is considered to be unpinned. ^The cache implementation -** may choose to evict unpinned pages at any time. -** -** ^(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 -** to xFetch().)^ -** -** ^The xRekey() method is used to change the key value associated with the -** page passed as the second argument from oldKey to newKey. ^If the cache -** previously contains an entry associated with newKey, it should be -** discarded. ^Any prior cache entry associated with newKey is guaranteed not -** to be pinned. -** -** ^When SQLite calls the xTruncate() method, the cache must discard all -** existing cache entries with page numbers (keys) greater than or equal -** to the value of the iLimit parameter passed to xTruncate(). ^If any -** of these pages are pinned, they are implicitly unpinned, meaning that -** they can be safely discarded. -** -** ^The xDestroy() method is used to delete a cache allocated by xCreate(). -** All resources associated with the specified cache should be freed. ^After -** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] -** handle invalid, and will not use it with any other sqlite3_pcache_methods -** functions. -*/ -typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; -struct sqlite3_pcache_methods { - void *pArg; - int (*xInit)(void*); - void (*xShutdown)(void*); - sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); - void (*xCachesize)(sqlite3_pcache*, int nCachesize); - int (*xPagecount)(sqlite3_pcache*); - void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); - void (*xUnpin)(sqlite3_pcache*, void*, int discard); - void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); - void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); - void (*xDestroy)(sqlite3_pcache*); -}; - -/* -** CAPI3REF: Online Backup Object -** EXPERIMENTAL -** -** The sqlite3_backup object records state information about an ongoing -** online backup operation. ^The sqlite3_backup object is created by -** a call to [sqlite3_backup_init()] and is destroyed by a call to -** [sqlite3_backup_finish()]. -** -** See Also: [Using the SQLite Online Backup API] -*/ -typedef struct sqlite3_backup sqlite3_backup; - -/* -** CAPI3REF: Online Backup API. -** EXPERIMENTAL -** -** The backup API copies the content of one database into another. -** It is useful either for creating backups of databases or -** for copying in-memory databases to or from persistent files. -** -** See Also: [Using the SQLite Online Backup API] -** -** ^Exclusive access is required to the destination database for the -** duration of the operation. ^However the source database is only -** read-locked while it is actually being read; it is not locked -** continuously for the entire backup operation. ^Thus, the backup may be -** performed on a live source database without preventing other users from -** reading or writing to the source database while the backup is underway. -** -** ^(To perform a backup operation: -**
    -**
  1. sqlite3_backup_init() is called once to initialize the -** backup, -**
  2. sqlite3_backup_step() is called one or more times to transfer -** the data between the two databases, and finally -**
  3. sqlite3_backup_finish() is called to release all resources -** associated with the backup operation. -**
)^ -** There should be exactly one call to sqlite3_backup_finish() for each -** successful call to sqlite3_backup_init(). -** -** sqlite3_backup_init() -** -** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the -** [database connection] associated with the destination database -** and the database name, respectively. -** ^The database name is "main" for the main database, "temp" for the -** temporary database, or the name specified after the AS keyword in -** an [ATTACH] statement for an attached database. -** ^The S and M arguments passed to -** sqlite3_backup_init(D,N,S,M) identify the [database connection] -** and database name of the source database, respectively. -** ^The source and destination [database connections] (parameters S and D) -** must be different or else sqlite3_backup_init(D,N,S,M) will file with -** an error. -** -** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is -** returned and an error code and error message are store3d in the -** destination [database connection] D. -** ^The error code and message for the failed call to sqlite3_backup_init() -** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or -** [sqlite3_errmsg16()] functions. -** ^A successful call to sqlite3_backup_init() returns a pointer to an -** [sqlite3_backup] object. -** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and -** sqlite3_backup_finish() functions to perform the specified backup -** operation. -** -** sqlite3_backup_step() -** -** ^Function sqlite3_backup_step(B,N) will copy up to N pages between -** the source and destination databases specified by [sqlite3_backup] object B. -** ^If N is negative, all remaining source pages are copied. -** ^If sqlite3_backup_step(B,N) successfully copies N pages and there -** are still more pages to be copied, then the function resturns [SQLITE_OK]. -** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages -** from source to destination, then it returns [SQLITE_DONE]. -** ^If an error occurs while running sqlite3_backup_step(B,N), -** then an [error code] is returned. ^As well as [SQLITE_OK] and -** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], -** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an -** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. -** -** ^The sqlite3_backup_step() might return [SQLITE_READONLY] if the destination -** database was opened read-only or if -** the destination is an in-memory database with a different page size -** from the source database. -** -** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then -** the [sqlite3_busy_handler | busy-handler function] -** is invoked (if one is specified). ^If the -** busy-handler returns non-zero before the lock is available, then -** [SQLITE_BUSY] is returned to the caller. ^In this case the call to -** sqlite3_backup_step() can be retried later. ^If the source -** [database connection] -** is being used to write to the source database when sqlite3_backup_step() -** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this -** case the call to sqlite3_backup_step() can be retried later on. ^(If -** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or -** [SQLITE_READONLY] is returned, then -** there is no point in retrying the call to sqlite3_backup_step(). These -** errors are considered fatal.)^ The application must accept -** that the backup operation has failed and pass the backup operation handle -** to the sqlite3_backup_finish() to release associated resources. -** -** ^The first call to sqlite3_backup_step() obtains an exclusive lock -** on the destination file. ^The exclusive lock is not released until either -** sqlite3_backup_finish() is called or the backup operation is complete -** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to -** sqlite3_backup_step() obtains a [shared lock] on the source database that -** lasts for the duration of the sqlite3_backup_step() call. -** ^Because the source database is not locked between calls to -** sqlite3_backup_step(), the source database may be modified mid-way -** through the backup process. ^If the source database is modified by an -** external process or via a database connection other than the one being -** used by the backup operation, then the backup will be automatically -** restarted by the next call to sqlite3_backup_step(). ^If the source -** database is modified by the using the same database connection as is used -** by the backup operation, then the backup database is automatically -** updated at the same time. -** -** sqlite3_backup_finish() -** -** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the -** application wishes to abandon the backup operation, the application -** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). -** ^The sqlite3_backup_finish() interfaces releases all -** resources associated with the [sqlite3_backup] object. -** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any -** active write-transaction on the destination database is rolled back. -** The [sqlite3_backup] object is invalid -** and may not be used following a call to sqlite3_backup_finish(). -** -** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no -** sqlite3_backup_step() errors occurred, regardless or whether or not -** sqlite3_backup_step() completed. -** ^If an out-of-memory condition or IO error occurred during any prior -** sqlite3_backup_step() call on the same [sqlite3_backup] object, then -** sqlite3_backup_finish() returns the corresponding [error code]. -** -** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() -** is not a permanent error and does not affect the return value of -** sqlite3_backup_finish(). -** -** sqlite3_backup_remaining(), sqlite3_backup_pagecount() -** -** ^Each call to sqlite3_backup_step() sets two values inside -** the [sqlite3_backup] object: the number of pages still to be backed -** up and the total number of pages in the source databae file. -** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces -** retrieve these two values, respectively. -** -** ^The values returned by these functions are only updated by -** sqlite3_backup_step(). ^If the source database is modified during a backup -** operation, then the values are not updated to account for any extra -** pages that need to be updated or the size of the source database file -** changing. -** -** Concurrent Usage of Database Handles -** -** ^The source [database connection] may be used by the application for other -** purposes while a backup operation is underway or being initialized. -** ^If SQLite is compiled and configured to support threadsafe database -** connections, then the source database connection may be used concurrently -** from within other threads. -** -** However, the application must guarantee that the destination -** [database connection] is not passed to any other API (by any thread) after -** sqlite3_backup_init() is called and before the corresponding call to -** sqlite3_backup_finish(). SQLite does not currently check to see -** if the application incorrectly accesses the destination [database connection] -** and so no error code is reported, but the operations may malfunction -** nevertheless. Use of the destination database connection while a -** backup is in progress might also also cause a mutex deadlock. -** -** If running in [shared cache mode], the application must -** guarantee that the shared cache used by the destination database -** is not accessed while the backup is running. In practice this means -** that the application must guarantee that the disk file being -** backed up to is not accessed by any connection within the process, -** not just the specific connection that was passed to sqlite3_backup_init(). -** -** The [sqlite3_backup] object itself is partially threadsafe. Multiple -** threads may safely make multiple concurrent calls to sqlite3_backup_step(). -** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() -** APIs are not strictly speaking threadsafe. If they are invoked at the -** same time as another thread is invoking sqlite3_backup_step() it is -** possible that they return invalid values. -*/ -SQLITE_API sqlite3_backup *sqlite3_backup_init( - sqlite3 *pDest, /* Destination database handle */ - const char *zDestName, /* Destination database name */ - sqlite3 *pSource, /* Source database handle */ - const char *zSourceName /* Source database name */ -); -SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); -SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); -SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); -SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); - -/* -** CAPI3REF: Unlock Notification -** EXPERIMENTAL -** -** ^When running in shared-cache mode, a database operation may fail with -** an [SQLITE_LOCKED] error if the required locks on the shared-cache or -** individual tables within the shared-cache cannot be obtained. See -** [SQLite Shared-Cache Mode] for a description of shared-cache locking. -** ^This API may be used to register a callback that SQLite will invoke -** when the connection currently holding the required lock relinquishes it. -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. -** -** See Also: [Using the SQLite Unlock Notification Feature]. -** -** ^Shared-cache locks are released when a database connection concludes -** its current transaction, either by committing it or rolling it back. -** -** ^When a connection (known as the blocked connection) fails to obtain a -** shared-cache lock and SQLITE_LOCKED is returned to the caller, the -** identity of the database connection (the blocking connection) that -** has locked the required resource is stored internally. ^After an -** application receives an SQLITE_LOCKED error, it may call the -** sqlite3_unlock_notify() method with the blocked connection handle as -** the first argument to register for a callback that will be invoked -** when the blocking connections current transaction is concluded. ^The -** callback is invoked from within the [sqlite3_step] or [sqlite3_close] -** call that concludes the blocking connections transaction. -** -** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, -** there is a chance that the blocking connection will have already -** concluded its transaction by the time sqlite3_unlock_notify() is invoked. -** If this happens, then the specified callback is invoked immediately, -** from within the call to sqlite3_unlock_notify().)^ -** -** ^If the blocked connection is attempting to obtain a write-lock on a -** shared-cache table, and more than one other connection currently holds -** a read-lock on the same table, then SQLite arbitrarily selects one of -** the other connections to use as the blocking connection. -** -** ^(There may be at most one unlock-notify callback registered by a -** blocked connection. If sqlite3_unlock_notify() is called when the -** blocked connection already has a registered unlock-notify callback, -** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is -** called with a NULL pointer as its second argument, then any existing -** unlock-notify callback is cancelled. ^The blocked connections -** unlock-notify callback may also be canceled by closing the blocked -** connection using [sqlite3_close()]. -** -** The unlock-notify callback is not reentrant. If an application invokes -** any sqlite3_xxx API functions from within an unlock-notify callback, a -** crash or deadlock may be the result. -** -** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always -** returns SQLITE_OK. -** -** Callback Invocation Details -** -** When an unlock-notify callback is registered, the application provides a -** single void* pointer that is passed to the callback when it is invoked. -** However, the signature of the callback function allows SQLite to pass -** it an array of void* context pointers. The first argument passed to -** an unlock-notify callback is a pointer to an array of void* pointers, -** and the second is the number of entries in the array. -** -** When a blocking connections transaction is concluded, there may be -** more than one blocked connection that has registered for an unlock-notify -** callback. ^If two or more such blocked connections have specified the -** same callback function, then instead of invoking the callback function -** multiple times, it is invoked once with the set of void* context pointers -** specified by the blocked connections bundled together into an array. -** This gives the application an opportunity to prioritize any actions -** related to the set of unblocked database connections. -** -** Deadlock Detection -** -** Assuming that after registering for an unlock-notify callback a -** database waits for the callback to be issued before taking any further -** action (a reasonable assumption), then using this API may cause the -** application to deadlock. For example, if connection X is waiting for -** connection Y's transaction to be concluded, and similarly connection -** Y is waiting on connection X's transaction, then neither connection -** will proceed and the system may remain deadlocked indefinitely. -** -** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock -** detection. ^If a given call to sqlite3_unlock_notify() would put the -** system in a deadlocked state, then SQLITE_LOCKED is returned and no -** unlock-notify callback is registered. The system is said to be in -** a deadlocked state if connection A has registered for an unlock-notify -** callback on the conclusion of connection B's transaction, and connection -** B has itself registered for an unlock-notify callback when connection -** A's transaction is concluded. ^Indirect deadlock is also detected, so -** the system is also considered to be deadlocked if connection B has -** registered for an unlock-notify callback on the conclusion of connection -** C's transaction, where connection C is waiting on connection A. ^Any -** number of levels of indirection are allowed. -** -** The "DROP TABLE" Exception -** -** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost -** always appropriate to call sqlite3_unlock_notify(). There is however, -** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, -** SQLite checks if there are any currently executing SELECT statements -** that belong to the same connection. If there are, SQLITE_LOCKED is -** returned. In this case there is no "blocking connection", so invoking -** sqlite3_unlock_notify() results in the unlock-notify callback being -** invoked immediately. If the application then re-attempts the "DROP TABLE" -** or "DROP INDEX" query, an infinite loop might be the result. -** -** One way around this problem is to check the extended error code returned -** by an sqlite3_step() call. ^(If there is a blocking connection, then the -** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in -** the special "DROP TABLE/INDEX" case, the extended error code is just -** SQLITE_LOCKED.)^ -*/ -SQLITE_API int sqlite3_unlock_notify( - sqlite3 *pBlocked, /* Waiting connection */ - void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ - void *pNotifyArg /* Argument to pass to xNotify */ -); - - -/* -** CAPI3REF: String Comparison -** EXPERIMENTAL -** -** ^The [sqlite3_strnicmp()] API allows applications and extensions to -** compare the contents of two buffers containing UTF-8 strings in a -** case-indendent fashion, using the same definition of case independence -** that SQLite uses internally when comparing identifiers. -*/ -SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); - -/* -** CAPI3REF: Error Logging Interface -** EXPERIMENTAL -** -** ^The [sqlite3_log()] interface writes a message into the error log -** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. -** ^If logging is enabled, the zFormat string and subsequent arguments are -** passed through to [sqlite3_vmprintf()] to generate the final output string. -** -** The sqlite3_log() interface is intended for use by extensions such as -** virtual tables, collating functions, and SQL functions. While there is -** nothing to prevent an application from calling sqlite3_log(), doing so -** is considered bad form. -** -** The zFormat string must not be NULL. -** -** To avoid deadlocks and other threading problems, the sqlite3_log() routine -** will not use dynamically allocated memory. The log message is stored in -** a fixed-length buffer on the stack. If the log message is longer than -** a few hundred characters, it will be truncated to the length of the -** buffer. -*/ -SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); - -/* -** Undo the hack that converts floating point types to integer for -** builds on processors without floating point support. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# undef double -#endif - -#ifdef __cplusplus -} /* End of the 'extern "C"' block */ -#endif -#endif - diff --git a/win32/sqlite3.lib b/win32/sqlite3.lib deleted file mode 100644 index 160223f6da8d6051774756c61468be85e39f5783..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41644 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 -#include -#include -#include -#include "sqlite3.h" -#include -#include - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) -# include -# if !defined(__RTP__) && !defined(_WRS_KERNEL) -# include -# endif -# include -# include -#endif - -#ifdef __OS2__ -# include -#endif - -#if defined(HAVE_READLINE) && HAVE_READLINE==1 -# include -# include -#else -# define readline(p) local_getline(p,stdin) -# define add_history(X) -# define read_history(X) -# define write_history(X) -# define stifle_history(X) -#endif - -#if defined(_WIN32) || defined(WIN32) -# include -#define isatty(h) _isatty(h) -#define access(f,m) _access((f),(m)) -#else -/* Make sure isatty() has a prototype. -*/ -extern int isatty(); -#endif - -#if defined(_WIN32_WCE) -/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty() - * thus we always assume that we have a console. That can be - * overridden with the -batch command line option. - */ -#define isatty(x) 1 -#endif - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(__RTP__) && !defined(_WRS_KERNEL) -#include -#include - -/* Saved resource information for the beginning of an operation */ -static struct rusage sBegin; - -/* True if the timer is enabled */ -static int enableTimer = 0; - -/* -** Begin timing an operation -*/ -static void beginTimer(void){ - if( enableTimer ){ - getrusage(RUSAGE_SELF, &sBegin); - } -} - -/* Return the difference of two time_structs in seconds */ -static double timeDiff(struct timeval *pStart, struct timeval *pEnd){ - return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + - (double)(pEnd->tv_sec - pStart->tv_sec); -} - -/* -** Print the timing results. -*/ -static void endTimer(void){ - if( enableTimer ){ - struct rusage sEnd; - getrusage(RUSAGE_SELF, &sEnd); - printf("CPU Time: user %f sys %f\n", - timeDiff(&sBegin.ru_utime, &sEnd.ru_utime), - timeDiff(&sBegin.ru_stime, &sEnd.ru_stime)); - } -} - -#define BEGIN_TIMER beginTimer() -#define END_TIMER endTimer() -#define HAS_TIMER 1 - -#elif (defined(_WIN32) || defined(WIN32)) - -#include - -/* Saved resource information for the beginning of an operation */ -static HANDLE hProcess; -static FILETIME ftKernelBegin; -static FILETIME ftUserBegin; -typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); -static GETPROCTIMES getProcessTimesAddr = NULL; - -/* True if the timer is enabled */ -static int enableTimer = 0; - -/* -** Check to see if we have timer support. Return 1 if necessary -** support found (or found previously). -*/ -static int hasTimer(void){ - if( getProcessTimesAddr ){ - return 1; - } else { - /* GetProcessTimes() isn't supported in WIN95 and some other Windows versions. - ** See if the version we are running on has it, and if it does, save off - ** a pointer to it and the current process handle. - */ - hProcess = GetCurrentProcess(); - if( hProcess ){ - HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll")); - if( NULL != hinstLib ){ - getProcessTimesAddr = (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes"); - if( NULL != getProcessTimesAddr ){ - return 1; - } - FreeLibrary(hinstLib); - } - } - } - return 0; -} - -/* -** Begin timing an operation -*/ -static void beginTimer(void){ - if( enableTimer && getProcessTimesAddr ){ - FILETIME ftCreation, ftExit; - getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin); - } -} - -/* Return the difference of two FILETIME structs in seconds */ -static double timeDiff(FILETIME *pStart, FILETIME *pEnd){ - sqlite_int64 i64Start = *((sqlite_int64 *) pStart); - sqlite_int64 i64End = *((sqlite_int64 *) pEnd); - return (double) ((i64End - i64Start) / 10000000.0); -} - -/* -** Print the timing results. -*/ -static void endTimer(void){ - if( enableTimer && getProcessTimesAddr){ - FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd; - getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd); - printf("CPU Time: user %f sys %f\n", - timeDiff(&ftUserBegin, &ftUserEnd), - timeDiff(&ftKernelBegin, &ftKernelEnd)); - } -} - -#define BEGIN_TIMER beginTimer() -#define END_TIMER endTimer() -#define HAS_TIMER hasTimer() - -#else -#define BEGIN_TIMER -#define END_TIMER -#define HAS_TIMER 0 -#endif - -/* -** Used to prevent warnings about unused parameters -*/ -#define UNUSED_PARAMETER(x) (void)(x) - -/* -** If the following flag is set, then command execution stops -** at an error if we are not interactive. -*/ -static int bail_on_error = 0; - -/* -** Threat stdin as an interactive input if the following variable -** is true. Otherwise, assume stdin is connected to a file or pipe. -*/ -static int stdin_is_interactive = 1; - -/* -** The following is the open SQLite database. We make a pointer -** to this database a static variable so that it can be accessed -** by the SIGINT handler to interrupt database processing. -*/ -static sqlite3 *db = 0; - -/* -** True if an interrupt (Control-C) has been received. -*/ -static volatile int seenInterrupt = 0; - -/* -** This is the name of our program. It is set in main(), used -** in a number of other places, mostly for error messages. -*/ -static char *Argv0; - -/* -** Prompt strings. Initialized in main. Settable with -** .prompt main continue -*/ -static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ -static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ - -/* -** Write I/O traces to the following stream. -*/ -#ifdef SQLITE_ENABLE_IOTRACE -static FILE *iotrace = 0; -#endif - -/* -** This routine works like printf in that its first argument is a -** format string and subsequent arguments are values to be substituted -** in place of % fields. The result of formatting this string -** is written to iotrace. -*/ -#ifdef SQLITE_ENABLE_IOTRACE -static void iotracePrintf(const char *zFormat, ...){ - va_list ap; - char *z; - if( iotrace==0 ) return; - va_start(ap, zFormat); - z = sqlite3_vmprintf(zFormat, ap); - va_end(ap); - fprintf(iotrace, "%s", z); - sqlite3_free(z); -} -#endif - - -/* -** Determines if a string is a number of not. -*/ -static int isNumber(const char *z, int *realnum){ - if( *z=='-' || *z=='+' ) z++; - if( !isdigit(*z) ){ - return 0; - } - z++; - if( realnum ) *realnum = 0; - while( isdigit(*z) ){ z++; } - if( *z=='.' ){ - z++; - if( !isdigit(*z) ) return 0; - while( isdigit(*z) ){ z++; } - if( realnum ) *realnum = 1; - } - if( *z=='e' || *z=='E' ){ - z++; - if( *z=='+' || *z=='-' ) z++; - if( !isdigit(*z) ) return 0; - while( isdigit(*z) ){ z++; } - if( realnum ) *realnum = 1; - } - return *z==0; -} - -/* -** A global char* and an SQL function to access its current value -** from within an SQL statement. This program used to use the -** sqlite_exec_printf() API to substitue a string into an SQL statement. -** The correct way to do this with sqlite3 is to use the bind API, but -** since the shell is built around the callback paradigm it would be a lot -** of work. Instead just use this hack, which is quite harmless. -*/ -static const char *zShellStatic = 0; -static void shellstaticFunc( - sqlite3_context *context, - int argc, - sqlite3_value **argv -){ - assert( 0==argc ); - assert( zShellStatic ); - UNUSED_PARAMETER(argc); - UNUSED_PARAMETER(argv); - sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC); -} - - -/* -** This routine reads a line of text from FILE in, stores -** the text in memory obtained from malloc() and returns a pointer -** to the text. NULL is returned at end of file, or if malloc() -** fails. -** -** The interface is like "readline" but no command-line editing -** is done. -*/ -static char *local_getline(char *zPrompt, FILE *in){ - char *zLine; - int nLine; - int n; - int eol; - - if( zPrompt && *zPrompt ){ - printf("%s",zPrompt); - fflush(stdout); - } - nLine = 100; - zLine = malloc( nLine ); - if( zLine==0 ) return 0; - n = 0; - eol = 0; - while( !eol ){ - if( n+100>nLine ){ - nLine = nLine*2 + 100; - zLine = realloc(zLine, nLine); - if( zLine==0 ) return 0; - } - if( fgets(&zLine[n], nLine - n, in)==0 ){ - if( n==0 ){ - free(zLine); - return 0; - } - zLine[n] = 0; - eol = 1; - break; - } - while( zLine[n] ){ n++; } - if( n>0 && zLine[n-1]=='\n' ){ - n--; - if( n>0 && zLine[n-1]=='\r' ) n--; - zLine[n] = 0; - eol = 1; - } - } - zLine = realloc( zLine, n+1 ); - return zLine; -} - -/* -** Retrieve a single line of input text. -** -** zPrior is a string of prior text retrieved. If not the empty -** string, then issue a continuation prompt. -*/ -static char *one_input_line(const char *zPrior, FILE *in){ - char *zPrompt; - char *zResult; - if( in!=0 ){ - return local_getline(0, in); - } - if( zPrior && zPrior[0] ){ - zPrompt = continuePrompt; - }else{ - zPrompt = mainPrompt; - } - zResult = readline(zPrompt); -#if defined(HAVE_READLINE) && HAVE_READLINE==1 - if( zResult && *zResult ) add_history(zResult); -#endif - return zResult; -} - -struct previous_mode_data { - int valid; /* Is there legit data in here? */ - int mode; - int showHeader; - int colWidth[100]; -}; - -/* -** An pointer to an instance of this structure is passed from -** the main program to the callback. This is used to communicate -** state and mode information. -*/ -struct callback_data { - sqlite3 *db; /* The database */ - int echoOn; /* True to echo input commands */ - int cnt; /* Number of records displayed so far */ - FILE *out; /* Write results here */ - int mode; /* An output mode setting */ - int writableSchema; /* True if PRAGMA writable_schema=ON */ - int showHeader; /* True to show column names in List or Column mode */ - char *zDestTable; /* Name of destination table when MODE_Insert */ - char separator[20]; /* Separator character for MODE_List */ - int colWidth[100]; /* Requested width of each column when in column mode*/ - int actualWidth[100]; /* Actual width of each column */ - char nullvalue[20]; /* The text to print when a NULL comes back from - ** the database */ - struct previous_mode_data explainPrev; - /* Holds the mode information just before - ** .explain ON */ - char outfile[FILENAME_MAX]; /* Filename for *out */ - const char *zDbFilename; /* name of the database file */ - sqlite3_stmt *pStmt; /* Current statement if any. */ - FILE *pLog; /* Write log output here */ -}; - -/* -** These are the allowed modes. -*/ -#define MODE_Line 0 /* One column per line. Blank line between records */ -#define MODE_Column 1 /* One record per line in neat columns */ -#define MODE_List 2 /* One record per line with a separator */ -#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ -#define MODE_Html 4 /* Generate an XHTML table */ -#define MODE_Insert 5 /* Generate SQL "insert" statements */ -#define MODE_Tcl 6 /* Generate ANSI-C or TCL quoted elements */ -#define MODE_Csv 7 /* Quote strings, numbers are plain */ -#define MODE_Explain 8 /* Like MODE_Column, but do not truncate data */ - -static const char *modeDescr[] = { - "line", - "column", - "list", - "semi", - "html", - "insert", - "tcl", - "csv", - "explain", -}; - -/* -** Number of elements in an array -*/ -#define ArraySize(X) (int)(sizeof(X)/sizeof(X[0])) - -/* -** Compute a string length that is limited to what can be stored in -** lower 30 bits of a 32-bit signed integer. -*/ -static int strlen30(const char *z){ - const char *z2 = z; - while( *z2 ){ z2++; } - return 0x3fffffff & (int)(z2 - z); -} - -/* -** A callback for the sqlite3_log() interface. -*/ -static void shellLog(void *pArg, int iErrCode, const char *zMsg){ - struct callback_data *p = (struct callback_data*)pArg; - if( p->pLog==0 ) return; - fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg); - fflush(p->pLog); -} - -/* -** Output the given string as a hex-encoded blob (eg. X'1234' ) -*/ -static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){ - int i; - char *zBlob = (char *)pBlob; - fprintf(out,"X'"); - for(i=0; i0 ){ - fprintf(out,"%.*s",i,z); - } - if( z[i]=='<' ){ - fprintf(out,"<"); - }else if( z[i]=='&' ){ - fprintf(out,"&"); - }else if( z[i]=='>' ){ - fprintf(out,">"); - }else if( z[i]=='\"' ){ - fprintf(out,"""); - }else if( z[i]=='\'' ){ - fprintf(out,"'"); - }else{ - break; - } - z += i + 1; - } -} - -/* -** If a field contains any character identified by a 1 in the following -** array, then the string must be quoted for CSV. -*/ -static const char needCsvQuote[] = { - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -}; - -/* -** Output a single term of CSV. Actually, p->separator is used for -** the separator, which may or may not be a comma. p->nullvalue is -** the null value. Strings are quoted using ANSI-C rules. Numbers -** appear outside of quotes. -*/ -static void output_csv(struct callback_data *p, const char *z, int bSep){ - FILE *out = p->out; - if( z==0 ){ - fprintf(out,"%s",p->nullvalue); - }else{ - int i; - int nSep = strlen30(p->separator); - for(i=0; z[i]; i++){ - if( needCsvQuote[((unsigned char*)z)[i]] - || (z[i]==p->separator[0] && - (nSep==1 || memcmp(z, p->separator, nSep)==0)) ){ - i = 0; - break; - } - } - if( i==0 ){ - putc('"', out); - for(i=0; z[i]; i++){ - if( z[i]=='"' ) putc('"', out); - putc(z[i], out); - } - putc('"', out); - }else{ - fprintf(out, "%s", z); - } - } - if( bSep ){ - fprintf(p->out, "%s", p->separator); - } -} - -#ifdef SIGINT -/* -** This routine runs when the user presses Ctrl-C -*/ -static void interrupt_handler(int NotUsed){ - UNUSED_PARAMETER(NotUsed); - seenInterrupt = 1; - if( db ) sqlite3_interrupt(db); -} -#endif - -/* -** This is the callback routine that the shell -** invokes for each row of a query result. -*/ -static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){ - int i; - struct callback_data *p = (struct callback_data*)pArg; - - switch( p->mode ){ - case MODE_Line: { - int w = 5; - if( azArg==0 ) break; - for(i=0; iw ) w = len; - } - if( p->cnt++>0 ) fprintf(p->out,"\n"); - for(i=0; iout,"%*s = %s\n", w, azCol[i], - azArg[i] ? azArg[i] : p->nullvalue); - } - break; - } - case MODE_Explain: - case MODE_Column: { - if( p->cnt++==0 ){ - for(i=0; icolWidth) ){ - w = p->colWidth[i]; - }else{ - w = 0; - } - if( w<=0 ){ - w = strlen30(azCol[i] ? azCol[i] : ""); - if( w<10 ) w = 10; - n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullvalue); - if( wactualWidth) ){ - p->actualWidth[i] = w; - } - if( p->showHeader ){ - fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " "); - } - } - if( p->showHeader ){ - for(i=0; iactualWidth) ){ - w = p->actualWidth[i]; - }else{ - w = 10; - } - fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------" - "----------------------------------------------------------", - i==nArg-1 ? "\n": " "); - } - } - } - if( azArg==0 ) break; - for(i=0; iactualWidth) ){ - w = p->actualWidth[i]; - }else{ - w = 10; - } - if( p->mode==MODE_Explain && azArg[i] && - strlen30(azArg[i])>w ){ - w = strlen30(azArg[i]); - } - fprintf(p->out,"%-*.*s%s",w,w, - azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " "); - } - break; - } - case MODE_Semi: - case MODE_List: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator); - } - } - if( azArg==0 ) break; - for(i=0; inullvalue; - fprintf(p->out, "%s", z); - if( iout, "%s", p->separator); - }else if( p->mode==MODE_Semi ){ - fprintf(p->out, ";\n"); - }else{ - fprintf(p->out, "\n"); - } - } - break; - } - case MODE_Html: { - if( p->cnt++==0 && p->showHeader ){ - fprintf(p->out,""); - for(i=0; iout,""); - output_html_string(p->out, azCol[i]); - fprintf(p->out,"\n"); - } - fprintf(p->out,"\n"); - } - if( azArg==0 ) break; - fprintf(p->out,""); - for(i=0; iout,""); - output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue); - fprintf(p->out,"\n"); - } - fprintf(p->out,"\n"); - break; - } - case MODE_Tcl: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,azCol[i] ? azCol[i] : ""); - fprintf(p->out, "%s", p->separator); - } - fprintf(p->out,"\n"); - } - if( azArg==0 ) break; - for(i=0; iout, azArg[i] ? azArg[i] : p->nullvalue); - fprintf(p->out, "%s", p->separator); - } - fprintf(p->out,"\n"); - break; - } - case MODE_Csv: { - if( p->cnt++==0 && p->showHeader ){ - for(i=0; iout,"\n"); - } - if( azArg==0 ) break; - for(i=0; iout,"\n"); - break; - } - case MODE_Insert: { - p->cnt++; - if( azArg==0 ) break; - fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable); - for(i=0; i0 ? ",": ""; - if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){ - fprintf(p->out,"%sNULL",zSep); - }else if( aiType && aiType[i]==SQLITE_TEXT ){ - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_quoted_string(p->out, azArg[i]); - }else if( aiType && (aiType[i]==SQLITE_INTEGER || aiType[i]==SQLITE_FLOAT) ){ - fprintf(p->out,"%s%s",zSep, azArg[i]); - }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){ - const void *pBlob = sqlite3_column_blob(p->pStmt, i); - int nBlob = sqlite3_column_bytes(p->pStmt, i); - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_hex_blob(p->out, pBlob, nBlob); - }else if( isNumber(azArg[i], 0) ){ - fprintf(p->out,"%s%s",zSep, azArg[i]); - }else{ - if( zSep[0] ) fprintf(p->out,"%s",zSep); - output_quoted_string(p->out, azArg[i]); - } - } - fprintf(p->out,");\n"); - break; - } - } - return 0; -} - -/* -** This is the callback routine that the SQLite library -** invokes for each row of a query result. -*/ -static int callback(void *pArg, int nArg, char **azArg, char **azCol){ - /* since we don't have type info, call the shell_callback with a NULL value */ - return shell_callback(pArg, nArg, azArg, azCol, NULL); -} - -/* -** Set the destination table field of the callback_data structure to -** the name of the table given. Escape any quote characters in the -** table name. -*/ -static void set_table_name(struct callback_data *p, const char *zName){ - int i, n; - int needQuote; - char *z; - - if( p->zDestTable ){ - free(p->zDestTable); - p->zDestTable = 0; - } - if( zName==0 ) return; - needQuote = !isalpha((unsigned char)*zName) && *zName!='_'; - for(i=n=0; zName[i]; i++, n++){ - if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){ - needQuote = 1; - if( zName[i]=='\'' ) n++; - } - } - if( needQuote ) n += 2; - z = p->zDestTable = malloc( n+1 ); - if( z==0 ){ - fprintf(stderr,"Error: out of memory\n"); - exit(1); - } - n = 0; - if( needQuote ) z[n++] = '\''; - for(i=0; zName[i]; i++){ - z[n++] = zName[i]; - if( zName[i]=='\'' ) z[n++] = '\''; - } - if( needQuote ) z[n++] = '\''; - z[n] = 0; -} - -/* zIn is either a pointer to a NULL-terminated string in memory obtained -** from malloc(), or a NULL pointer. The string pointed to by zAppend is -** added to zIn, and the result returned in memory obtained from malloc(). -** zIn, if it was not NULL, is freed. -** -** If the third argument, quote, is not '\0', then it is used as a -** quote character for zAppend. -*/ -static char *appendText(char *zIn, char const *zAppend, char quote){ - int len; - int i; - int nAppend = strlen30(zAppend); - int nIn = (zIn?strlen30(zIn):0); - - len = nAppend+nIn+1; - if( quote ){ - len += 2; - for(i=0; iechoOn ){ - const char *zStmtSql = sqlite3_sql(pStmt); - fprintf(pArg->out,"%s\n", zStmtSql ? zStmtSql : zSql); - } - - /* perform the first step. this will tell us if we - ** have a result set or not and how wide it is. - */ - rc = sqlite3_step(pStmt); - /* if we have a result set... */ - if( SQLITE_ROW == rc ){ - /* if we have a callback... */ - if( xCallback ){ - /* allocate space for col name ptr, value ptr, and type */ - int nCol = sqlite3_column_count(pStmt); - void *pData = sqlite3_malloc(3*nCol*sizeof(const char*) + 1); - if( !pData ){ - rc = SQLITE_NOMEM; - }else{ - char **azCols = (char **)pData; /* Names of result columns */ - char **azVals = &azCols[nCol]; /* Results */ - int *aiTypes = (int *)&azVals[nCol]; /* Result types */ - int i; - assert(sizeof(int) <= sizeof(char *)); - /* save off ptrs to column names */ - for(i=0; ipStmt = pStmt; - pArg->cnt = 0; - } - do{ - /* extract the data and data types */ - for(i=0; ipStmt = NULL; - } - } - }else{ - do{ - rc = sqlite3_step(pStmt); - } while( rc == SQLITE_ROW ); - } - } - - /* Finalize the statement just executed. If this fails, save a - ** copy of the error message. Otherwise, set zSql to point to the - ** next statement to execute. */ - rc = sqlite3_finalize(pStmt); - if( rc==SQLITE_OK ){ - zSql = zLeftover; - while( isspace(zSql[0]) ) zSql++; - }else if( pzErrMsg ){ - *pzErrMsg = save_err_msg(db); - } - } - } /* end while */ - - return rc; -} - - -/* -** This is a different callback routine used for dumping the database. -** Each row received by this callback consists of a table name, -** the table type ("index" or "table") and SQL to create the table. -** This routine should print text sufficient to recreate the table. -*/ -static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ - int rc; - const char *zTable; - const char *zType; - const char *zSql; - const char *zPrepStmt = 0; - struct callback_data *p = (struct callback_data *)pArg; - - UNUSED_PARAMETER(azCol); - if( nArg!=3 ) return 1; - zTable = azArg[0]; - zType = azArg[1]; - zSql = azArg[2]; - - if( strcmp(zTable, "sqlite_sequence")==0 ){ - zPrepStmt = "DELETE FROM sqlite_sequence;\n"; - }else if( strcmp(zTable, "sqlite_stat1")==0 ){ - fprintf(p->out, "ANALYZE sqlite_master;\n"); - }else if( strncmp(zTable, "sqlite_", 7)==0 ){ - return 0; - }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){ - char *zIns; - if( !p->writableSchema ){ - fprintf(p->out, "PRAGMA writable_schema=ON;\n"); - p->writableSchema = 1; - } - zIns = sqlite3_mprintf( - "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" - "VALUES('table','%q','%q',0,'%q');", - zTable, zTable, zSql); - fprintf(p->out, "%s\n", zIns); - sqlite3_free(zIns); - return 0; - }else{ - fprintf(p->out, "%s;\n", zSql); - } - - if( strcmp(zType, "table")==0 ){ - sqlite3_stmt *pTableInfo = 0; - char *zSelect = 0; - char *zTableInfo = 0; - char *zTmp = 0; - int nRow = 0; - - zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0); - zTableInfo = appendText(zTableInfo, zTable, '"'); - zTableInfo = appendText(zTableInfo, ");", 0); - - rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0); - free(zTableInfo); - if( rc!=SQLITE_OK || !pTableInfo ){ - return 1; - } - - zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0); - zTmp = appendText(zTmp, zTable, '"'); - if( zTmp ){ - zSelect = appendText(zSelect, zTmp, '\''); - } - zSelect = appendText(zSelect, " || ' VALUES(' || ", 0); - rc = sqlite3_step(pTableInfo); - while( rc==SQLITE_ROW ){ - const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1); - zSelect = appendText(zSelect, "quote(", 0); - zSelect = appendText(zSelect, zText, '"'); - rc = sqlite3_step(pTableInfo); - if( rc==SQLITE_ROW ){ - zSelect = appendText(zSelect, ") || ',' || ", 0); - }else{ - zSelect = appendText(zSelect, ") ", 0); - } - nRow++; - } - rc = sqlite3_finalize(pTableInfo); - if( rc!=SQLITE_OK || nRow==0 ){ - free(zSelect); - return 1; - } - zSelect = appendText(zSelect, "|| ')' FROM ", 0); - zSelect = appendText(zSelect, zTable, '"'); - - rc = run_table_dump_query(p->out, p->db, zSelect, zPrepStmt); - if( rc==SQLITE_CORRUPT ){ - zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0); - rc = run_table_dump_query(p->out, p->db, zSelect, 0); - } - if( zSelect ) free(zSelect); - } - return 0; -} - -/* -** Run zQuery. Use dump_callback() as the callback routine so that -** the contents of the query are output as SQL statements. -** -** If we get a SQLITE_CORRUPT error, rerun the query after appending -** "ORDER BY rowid DESC" to the end. -*/ -static int run_schema_dump_query( - struct callback_data *p, - const char *zQuery, - char **pzErrMsg -){ - int rc; - rc = sqlite3_exec(p->db, zQuery, dump_callback, p, pzErrMsg); - if( rc==SQLITE_CORRUPT ){ - char *zQ2; - int len = strlen30(zQuery); - if( pzErrMsg ) sqlite3_free(*pzErrMsg); - zQ2 = malloc( len+100 ); - if( zQ2==0 ) return rc; - sqlite3_snprintf(sizeof(zQ2), zQ2, "%s ORDER BY rowid DESC", zQuery); - rc = sqlite3_exec(p->db, zQ2, dump_callback, p, pzErrMsg); - free(zQ2); - } - return rc; -} - -/* -** Text of a help message -*/ -static char zHelp[] = - ".backup ?DB? FILE Backup DB (default \"main\") to FILE\n" - ".bail ON|OFF Stop after hitting an error. Default OFF\n" - ".databases List names and files of attached databases\n" - ".dump ?TABLE? ... Dump the database in an SQL text format\n" - " If TABLE specified, only dump tables matching\n" - " LIKE pattern TABLE.\n" - ".echo ON|OFF Turn command echo on or off\n" - ".exit Exit this program\n" - ".explain ?ON|OFF? Turn output mode suitable for EXPLAIN on or off.\n" - " With no args, it turns EXPLAIN on.\n" - ".header(s) ON|OFF Turn display of headers on or off\n" - ".help Show this message\n" - ".import FILE TABLE Import data from FILE into TABLE\n" - ".indices ?TABLE? Show names of all indices\n" - " If TABLE specified, only show indices for tables\n" - " matching LIKE pattern TABLE.\n" -#ifdef SQLITE_ENABLE_IOTRACE - ".iotrace FILE Enable I/O diagnostic logging to FILE\n" -#endif -#ifndef SQLITE_OMIT_LOAD_EXTENSION - ".load FILE ?ENTRY? Load an extension library\n" -#endif - ".log FILE|off Turn logging on or off. FILE can be stderr/stdout\n" - ".mode MODE ?TABLE? Set output mode where MODE is one of:\n" - " csv Comma-separated values\n" - " column Left-aligned columns. (See .width)\n" - " html HTML code\n" - " insert SQL insert statements for TABLE\n" - " line One value per line\n" - " list Values delimited by .separator string\n" - " tabs Tab-separated values\n" - " tcl TCL list elements\n" - ".nullvalue STRING Print STRING in place of NULL values\n" - ".output FILENAME Send output to FILENAME\n" - ".output stdout Send output to the screen\n" - ".prompt MAIN CONTINUE Replace the standard prompts\n" - ".quit Exit this program\n" - ".read FILENAME Execute SQL in FILENAME\n" - ".restore ?DB? FILE Restore content of DB (default \"main\") from FILE\n" - ".schema ?TABLE? Show the CREATE statements\n" - " If TABLE specified, only show tables matching\n" - " LIKE pattern TABLE.\n" - ".separator STRING Change separator used by output mode and .import\n" - ".show Show the current values for various settings\n" - ".tables ?TABLE? List names of tables\n" - " If TABLE specified, only list tables matching\n" - " LIKE pattern TABLE.\n" - ".timeout MS Try opening locked tables for MS milliseconds\n" - ".width NUM1 NUM2 ... Set column widths for \"column\" mode\n" -; - -static char zTimerHelp[] = - ".timer ON|OFF Turn the CPU timer measurement on or off\n" -; - -/* Forward reference */ -static int process_input(struct callback_data *p, FILE *in); - -/* -** Make sure the database is open. If it is not, then open it. If -** the database fails to open, print an error message and exit. -*/ -static void open_db(struct callback_data *p){ - if( p->db==0 ){ - sqlite3_open(p->zDbFilename, &p->db); - db = p->db; - if( db && sqlite3_errcode(db)==SQLITE_OK ){ - sqlite3_create_function(db, "shellstatic", 0, SQLITE_UTF8, 0, - shellstaticFunc, 0, 0); - } - if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){ - fprintf(stderr,"Error: unable to open database \"%s\": %s\n", - p->zDbFilename, sqlite3_errmsg(db)); - exit(1); - } -#ifndef SQLITE_OMIT_LOAD_EXTENSION - sqlite3_enable_load_extension(p->db, 1); -#endif - } -} - -/* -** Do C-language style dequoting. -** -** \t -> tab -** \n -> newline -** \r -> carriage return -** \NNN -> ascii character NNN in octal -** \\ -> backslash -*/ -static void resolve_backslashes(char *z){ - int i, j; - char c; - for(i=j=0; (c = z[i])!=0; i++, j++){ - if( c=='\\' ){ - c = z[++i]; - if( c=='n' ){ - c = '\n'; - }else if( c=='t' ){ - c = '\t'; - }else if( c=='r' ){ - c = '\r'; - }else if( c>='0' && c<='7' ){ - c -= '0'; - if( z[i+1]>='0' && z[i+1]<='7' ){ - i++; - c = (c<<3) + z[i] - '0'; - if( z[i+1]>='0' && z[i+1]<='7' ){ - i++; - c = (c<<3) + z[i] - '0'; - } - } - } - } - z[j] = c; - } - z[j] = 0; -} - -/* -** Interpret zArg as a boolean value. Return either 0 or 1. -*/ -static int booleanValue(char *zArg){ - int val = atoi(zArg); - int j; - for(j=0; zArg[j]; j++){ - zArg[j] = (char)tolower(zArg[j]); - } - if( strcmp(zArg,"on")==0 ){ - val = 1; - }else if( strcmp(zArg,"yes")==0 ){ - val = 1; - } - return val; -} - -/* -** If an input line begins with "." then invoke this routine to -** process that line. -** -** Return 1 on error, 2 to exit, and 0 otherwise. -*/ -static int do_meta_command(char *zLine, struct callback_data *p){ - int i = 1; - int nArg = 0; - int n, c; - int rc = 0; - char *azArg[50]; - - /* Parse the input line into tokens. - */ - while( zLine[i] && nArg=3 && strncmp(azArg[0], "backup", n)==0 && nArg>1 && nArg<4){ - const char *zDestFile; - const char *zDb; - sqlite3 *pDest; - sqlite3_backup *pBackup; - if( nArg==2 ){ - zDestFile = azArg[1]; - zDb = "main"; - }else{ - zDestFile = azArg[2]; - zDb = azArg[1]; - } - rc = sqlite3_open(zDestFile, &pDest); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zDestFile); - sqlite3_close(pDest); - return 1; - } - open_db(p); - pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb); - if( pBackup==0 ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); - sqlite3_close(pDest); - return 1; - } - while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){} - sqlite3_backup_finish(pBackup); - if( rc==SQLITE_DONE ){ - rc = 0; - }else{ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest)); - rc = 1; - } - sqlite3_close(pDest); - }else - - if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 && nArg>1 && nArg<3 ){ - bail_on_error = booleanValue(azArg[1]); - }else - - if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 1; - data.mode = MODE_Column; - data.colWidth[0] = 3; - data.colWidth[1] = 15; - data.colWidth[2] = 58; - data.cnt = 0; - sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - } - }else - - if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){ - char *zErrMsg = 0; - open_db(p); - /* When playing back a "dump", the content might appear in an order - ** which causes immediate foreign key constraints to be violated. - ** So disable foreign-key constraint enforcement to prevent problems. */ - fprintf(p->out, "PRAGMA foreign_keys=OFF;\n"); - fprintf(p->out, "BEGIN TRANSACTION;\n"); - p->writableSchema = 0; - sqlite3_exec(p->db, "PRAGMA writable_schema=ON", 0, 0, 0); - if( nArg==1 ){ - run_schema_dump_query(p, - "SELECT name, type, sql FROM sqlite_master " - "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'", 0 - ); - run_schema_dump_query(p, - "SELECT name, type, sql FROM sqlite_master " - "WHERE name=='sqlite_sequence'", 0 - ); - run_table_dump_query(p->out, p->db, - "SELECT sql FROM sqlite_master " - "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0 - ); - }else{ - int i; - for(i=1; iout, p->db, - "SELECT sql FROM sqlite_master " - "WHERE sql NOT NULL" - " AND type IN ('index','trigger','view')" - " AND tbl_name LIKE shellstatic()", 0 - ); - zShellStatic = 0; - } - } - if( p->writableSchema ){ - fprintf(p->out, "PRAGMA writable_schema=OFF;\n"); - p->writableSchema = 0; - } - sqlite3_exec(p->db, "PRAGMA writable_schema=OFF", 0, 0, 0); - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - }else{ - fprintf(p->out, "COMMIT;\n"); - } - }else - - if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 && nArg<3 ){ - p->echoOn = booleanValue(azArg[1]); - }else - - if( c=='e' && strncmp(azArg[0], "exit", n)==0 && nArg==1 ){ - rc = 2; - }else - - if( c=='e' && strncmp(azArg[0], "explain", n)==0 && nArg<3 ){ - int val = nArg>=2 ? booleanValue(azArg[1]) : 1; - if(val == 1) { - if(!p->explainPrev.valid) { - p->explainPrev.valid = 1; - p->explainPrev.mode = p->mode; - p->explainPrev.showHeader = p->showHeader; - memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth)); - } - /* We could put this code under the !p->explainValid - ** condition so that it does not execute if we are already in - ** explain mode. However, always executing it allows us an easy - ** was to reset to explain mode in case the user previously - ** did an .explain followed by a .width, .mode or .header - ** command. - */ - p->mode = MODE_Explain; - p->showHeader = 1; - memset(p->colWidth,0,ArraySize(p->colWidth)); - p->colWidth[0] = 4; /* addr */ - p->colWidth[1] = 13; /* opcode */ - p->colWidth[2] = 4; /* P1 */ - p->colWidth[3] = 4; /* P2 */ - p->colWidth[4] = 4; /* P3 */ - p->colWidth[5] = 13; /* P4 */ - p->colWidth[6] = 2; /* P5 */ - p->colWidth[7] = 13; /* Comment */ - }else if (p->explainPrev.valid) { - p->explainPrev.valid = 0; - p->mode = p->explainPrev.mode; - p->showHeader = p->explainPrev.showHeader; - memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth)); - } - }else - - if( c=='h' && (strncmp(azArg[0], "header", n)==0 || - strncmp(azArg[0], "headers", n)==0) && nArg>1 && nArg<3 ){ - p->showHeader = booleanValue(azArg[1]); - }else - - if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ - fprintf(stderr,"%s",zHelp); - if( HAS_TIMER ){ - fprintf(stderr,"%s",zTimerHelp); - } - }else - - if( c=='i' && strncmp(azArg[0], "import", n)==0 && nArg==3 ){ - char *zTable = azArg[2]; /* Insert data into this table */ - char *zFile = azArg[1]; /* The file from which to extract data */ - sqlite3_stmt *pStmt = NULL; /* A statement */ - int nCol; /* Number of columns in the table */ - int nByte; /* Number of bytes in an SQL string */ - int i, j; /* Loop counters */ - int nSep; /* Number of bytes in p->separator[] */ - char *zSql; /* An SQL statement */ - char *zLine; /* A single line of input from the file */ - char **azCol; /* zLine[] broken up into columns */ - char *zCommit; /* How to commit changes */ - FILE *in; /* The input file */ - int lineno = 0; /* Line number of input file */ - - open_db(p); - nSep = strlen30(p->separator); - if( nSep==0 ){ - fprintf(stderr, "Error: non-null separator required for import\n"); - return 1; - } - zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - return 1; - } - nByte = strlen30(zSql); - rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); - sqlite3_free(zSql); - if( rc ){ - if (pStmt) sqlite3_finalize(pStmt); - fprintf(stderr,"Error: %s\n", sqlite3_errmsg(db)); - return 1; - } - nCol = sqlite3_column_count(pStmt); - sqlite3_finalize(pStmt); - pStmt = 0; - if( nCol==0 ) return 0; /* no columns, no error */ - zSql = malloc( nByte + 20 + nCol*2 ); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - return 1; - } - sqlite3_snprintf(nByte+20, zSql, "INSERT INTO '%q' VALUES(?", zTable); - j = strlen30(zSql); - for(i=1; idb, zSql, -1, &pStmt, 0); - free(zSql); - if( rc ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db)); - if (pStmt) sqlite3_finalize(pStmt); - return 1; - } - in = fopen(zFile, "rb"); - if( in==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); - sqlite3_finalize(pStmt); - return 1; - } - azCol = malloc( sizeof(azCol[0])*(nCol+1) ); - if( azCol==0 ){ - fprintf(stderr, "Error: out of memory\n"); - fclose(in); - sqlite3_finalize(pStmt); - return 1; - } - sqlite3_exec(p->db, "BEGIN", 0, 0, 0); - zCommit = "COMMIT"; - while( (zLine = local_getline(0, in))!=0 ){ - char *z; - i = 0; - lineno++; - azCol[0] = zLine; - for(i=0, z=zLine; *z && *z!='\n' && *z!='\r'; z++){ - if( *z==p->separator[0] && strncmp(z, p->separator, nSep)==0 ){ - *z = 0; - i++; - if( idb, zCommit, 0, 0, 0); - }else - - if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 0; - data.mode = MODE_List; - if( nArg==1 ){ - rc = sqlite3_exec(p->db, - "SELECT name FROM sqlite_master " - "WHERE type='index' AND name NOT LIKE 'sqlite_%' " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type='index' " - "ORDER BY 1", - callback, &data, &zErrMsg - ); - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_exec(p->db, - "SELECT name FROM sqlite_master " - "WHERE type='index' AND tbl_name LIKE shellstatic() " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type='index' AND tbl_name LIKE shellstatic() " - "ORDER BY 1", - callback, &data, &zErrMsg - ); - zShellStatic = 0; - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); - rc = 1; - } - }else - -#ifdef SQLITE_ENABLE_IOTRACE - if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){ - extern void (*sqlite3IoTrace)(const char*, ...); - if( iotrace && iotrace!=stdout ) fclose(iotrace); - iotrace = 0; - if( nArg<2 ){ - sqlite3IoTrace = 0; - }else if( strcmp(azArg[1], "-")==0 ){ - sqlite3IoTrace = iotracePrintf; - iotrace = stdout; - }else{ - iotrace = fopen(azArg[1], "w"); - if( iotrace==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", azArg[1]); - sqlite3IoTrace = 0; - rc = 1; - }else{ - sqlite3IoTrace = iotracePrintf; - } - } - }else -#endif - -#ifndef SQLITE_OMIT_LOAD_EXTENSION - if( c=='l' && strncmp(azArg[0], "load", n)==0 && nArg>=2 ){ - const char *zFile, *zProc; - char *zErrMsg = 0; - zFile = azArg[1]; - zProc = nArg>=3 ? azArg[2] : 0; - open_db(p); - rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - } - }else -#endif - - if( c=='l' && strncmp(azArg[0], "log", n)==0 && nArg>=1 ){ - const char *zFile = azArg[1]; - if( p->pLog && p->pLog!=stdout && p->pLog!=stderr ){ - fclose(p->pLog); - p->pLog = 0; - } - if( strcmp(zFile,"stdout")==0 ){ - p->pLog = stdout; - }else if( strcmp(zFile, "stderr")==0 ){ - p->pLog = stderr; - }else if( strcmp(zFile, "off")==0 ){ - p->pLog = 0; - }else{ - p->pLog = fopen(zFile, "w"); - if( p->pLog==0 ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zFile); - } - } - }else - - if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==2 ){ - int n2 = strlen30(azArg[1]); - if( (n2==4 && strncmp(azArg[1],"line",n2)==0) - || - (n2==5 && strncmp(azArg[1],"lines",n2)==0) ){ - p->mode = MODE_Line; - }else if( (n2==6 && strncmp(azArg[1],"column",n2)==0) - || - (n2==7 && strncmp(azArg[1],"columns",n2)==0) ){ - p->mode = MODE_Column; - }else if( n2==4 && strncmp(azArg[1],"list",n2)==0 ){ - p->mode = MODE_List; - }else if( n2==4 && strncmp(azArg[1],"html",n2)==0 ){ - p->mode = MODE_Html; - }else if( n2==3 && strncmp(azArg[1],"tcl",n2)==0 ){ - p->mode = MODE_Tcl; - }else if( n2==3 && strncmp(azArg[1],"csv",n2)==0 ){ - p->mode = MODE_Csv; - sqlite3_snprintf(sizeof(p->separator), p->separator, ","); - }else if( n2==4 && strncmp(azArg[1],"tabs",n2)==0 ){ - p->mode = MODE_List; - sqlite3_snprintf(sizeof(p->separator), p->separator, "\t"); - }else if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){ - p->mode = MODE_Insert; - set_table_name(p, "table"); - }else { - fprintf(stderr,"Error: mode should be one of: " - "column csv html insert line list tabs tcl\n"); - rc = 1; - } - }else - - if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg==3 ){ - int n2 = strlen30(azArg[1]); - if( n2==6 && strncmp(azArg[1],"insert",n2)==0 ){ - p->mode = MODE_Insert; - set_table_name(p, azArg[2]); - }else { - fprintf(stderr, "Error: invalid arguments: " - " \"%s\". Enter \".help\" for help\n", azArg[2]); - rc = 1; - } - }else - - if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) { - sqlite3_snprintf(sizeof(p->nullvalue), p->nullvalue, - "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]); - }else - - if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){ - if( p->out!=stdout ){ - fclose(p->out); - } - if( strcmp(azArg[1],"stdout")==0 ){ - p->out = stdout; - sqlite3_snprintf(sizeof(p->outfile), p->outfile, "stdout"); - }else{ - p->out = fopen(azArg[1], "wb"); - if( p->out==0 ){ - fprintf(stderr,"Error: cannot write to \"%s\"\n", azArg[1]); - p->out = stdout; - rc = 1; - } else { - sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", azArg[1]); - } - } - }else - - if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){ - if( nArg >= 2) { - strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); - } - if( nArg >= 3) { - strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); - } - }else - - if( c=='q' && strncmp(azArg[0], "quit", n)==0 && nArg==1 ){ - rc = 2; - }else - - if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 && nArg==2 ){ - FILE *alt = fopen(azArg[1], "rb"); - if( alt==0 ){ - fprintf(stderr,"Error: cannot open \"%s\"\n", azArg[1]); - rc = 1; - }else{ - rc = process_input(p, alt); - fclose(alt); - } - }else - - if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 && nArg>1 && nArg<4){ - const char *zSrcFile; - const char *zDb; - sqlite3 *pSrc; - sqlite3_backup *pBackup; - int nTimeout = 0; - - if( nArg==2 ){ - zSrcFile = azArg[1]; - zDb = "main"; - }else{ - zSrcFile = azArg[2]; - zDb = azArg[1]; - } - rc = sqlite3_open(zSrcFile, &pSrc); - if( rc!=SQLITE_OK ){ - fprintf(stderr, "Error: cannot open \"%s\"\n", zSrcFile); - sqlite3_close(pSrc); - return 1; - } - open_db(p); - pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main"); - if( pBackup==0 ){ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); - sqlite3_close(pSrc); - return 1; - } - while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK - || rc==SQLITE_BUSY ){ - if( rc==SQLITE_BUSY ){ - if( nTimeout++ >= 3 ) break; - sqlite3_sleep(100); - } - } - sqlite3_backup_finish(pBackup); - if( rc==SQLITE_DONE ){ - rc = 0; - }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){ - fprintf(stderr, "Error: source database is busy\n"); - rc = 1; - }else{ - fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db)); - rc = 1; - } - sqlite3_close(pSrc); - }else - - if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){ - struct callback_data data; - char *zErrMsg = 0; - open_db(p); - memcpy(&data, p, sizeof(data)); - data.showHeader = 0; - data.mode = MODE_Semi; - if( nArg>1 ){ - int i; - for(i=0; azArg[1][i]; i++) azArg[1][i] = (char)tolower(azArg[1][i]); - if( strcmp(azArg[1],"sqlite_master")==0 ){ - char *new_argv[2], *new_colv[2]; - new_argv[0] = "CREATE TABLE sqlite_master (\n" - " type text,\n" - " name text,\n" - " tbl_name text,\n" - " rootpage integer,\n" - " sql text\n" - ")"; - new_argv[1] = 0; - new_colv[0] = "sql"; - new_colv[1] = 0; - callback(&data, 1, new_argv, new_colv); - rc = SQLITE_OK; - }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){ - char *new_argv[2], *new_colv[2]; - new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" - " type text,\n" - " name text,\n" - " tbl_name text,\n" - " rootpage integer,\n" - " sql text\n" - ")"; - new_argv[1] = 0; - new_colv[0] = "sql"; - new_colv[1] = 0; - callback(&data, 1, new_argv, new_colv); - rc = SQLITE_OK; - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_exec(p->db, - "SELECT sql FROM " - " (SELECT sql sql, type type, tbl_name tbl_name, name name" - " FROM sqlite_master UNION ALL" - " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) " - "WHERE tbl_name LIKE shellstatic() AND type!='meta' AND sql NOTNULL " - "ORDER BY substr(type,2,1), name", - callback, &data, &zErrMsg); - zShellStatic = 0; - } - }else{ - rc = sqlite3_exec(p->db, - "SELECT sql FROM " - " (SELECT sql sql, type type, tbl_name tbl_name, name name" - " FROM sqlite_master UNION ALL" - " SELECT sql, type, tbl_name, name FROM sqlite_temp_master) " - "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%'" - "ORDER BY substr(type,2,1), name", - callback, &data, &zErrMsg - ); - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying schema information\n"); - rc = 1; - }else{ - rc = 0; - } - }else - - if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){ - sqlite3_snprintf(sizeof(p->separator), p->separator, - "%.*s", (int)sizeof(p->separator)-1, azArg[1]); - }else - - if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){ - int i; - fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off"); - fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off"); - fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off"); - fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]); - fprintf(p->out,"%9.9s: ", "nullvalue"); - output_c_string(p->out, p->nullvalue); - fprintf(p->out, "\n"); - fprintf(p->out,"%9.9s: %s\n","output", - strlen30(p->outfile) ? p->outfile : "stdout"); - fprintf(p->out,"%9.9s: ", "separator"); - output_c_string(p->out, p->separator); - fprintf(p->out, "\n"); - fprintf(p->out,"%9.9s: ","width"); - for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) { - fprintf(p->out,"%d ",p->colWidth[i]); - } - fprintf(p->out,"\n"); - }else - - if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 && nArg<3 ){ - char **azResult; - int nRow; - char *zErrMsg; - open_db(p); - if( nArg==1 ){ - rc = sqlite3_get_table(p->db, - "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type IN ('table','view') " - "ORDER BY 1", - &azResult, &nRow, 0, &zErrMsg - ); - }else{ - zShellStatic = azArg[1]; - rc = sqlite3_get_table(p->db, - "SELECT name FROM sqlite_master " - "WHERE type IN ('table','view') AND name LIKE shellstatic() " - "UNION ALL " - "SELECT name FROM sqlite_temp_master " - "WHERE type IN ('table','view') AND name LIKE shellstatic() " - "ORDER BY 1", - &azResult, &nRow, 0, &zErrMsg - ); - zShellStatic = 0; - } - if( zErrMsg ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - sqlite3_free(zErrMsg); - rc = 1; - }else if( rc != SQLITE_OK ){ - fprintf(stderr,"Error: querying sqlite_master and sqlite_temp_master\n"); - rc = 1; - }else{ - int len, maxlen = 0; - int i, j; - int nPrintCol, nPrintRow; - for(i=1; i<=nRow; i++){ - if( azResult[i]==0 ) continue; - len = strlen30(azResult[i]); - if( len>maxlen ) maxlen = len; - } - nPrintCol = 80/(maxlen+2); - if( nPrintCol<1 ) nPrintCol = 1; - nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; - for(i=0; i4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){ - open_db(p); - sqlite3_busy_timeout(p->db, atoi(azArg[1])); - }else - - if( HAS_TIMER && c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 && nArg==2 ){ - enableTimer = booleanValue(azArg[1]); - }else - - if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){ - int j; - assert( nArg<=ArraySize(azArg) ); - for(j=1; jcolWidth); j++){ - p->colWidth[j-1] = atoi(azArg[j]); - } - }else - - { - fprintf(stderr, "Error: unknown command or invalid arguments: " - " \"%s\". Enter \".help\" for help\n", azArg[0]); - rc = 1; - } - - return rc; -} - -/* -** Return TRUE if a semicolon occurs anywhere in the first N characters -** of string z[]. -*/ -static int _contains_semicolon(const char *z, int N){ - int i; - for(i=0; iout); - free(zLine); - zLine = one_input_line(zSql, in); - if( zLine==0 ){ - break; /* We have reached EOF */ - } - if( seenInterrupt ){ - if( in!=0 ) break; - seenInterrupt = 0; - } - lineno++; - if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue; - if( zLine && zLine[0]=='.' && nSql==0 ){ - if( p->echoOn ) printf("%s\n", zLine); - rc = do_meta_command(zLine, p); - if( rc==2 ){ /* exit requested */ - break; - }else if( rc ){ - errCnt++; - } - continue; - } - if( _is_command_terminator(zLine) && _is_complete(zSql, nSql) ){ - memcpy(zLine,";",2); - } - nSqlPrior = nSql; - if( zSql==0 ){ - int i; - for(i=0; zLine[i] && isspace((unsigned char)zLine[i]); i++){} - if( zLine[i]!=0 ){ - nSql = strlen30(zLine); - zSql = malloc( nSql+3 ); - if( zSql==0 ){ - fprintf(stderr, "Error: out of memory\n"); - exit(1); - } - memcpy(zSql, zLine, nSql+1); - startline = lineno; - } - }else{ - int len = strlen30(zLine); - zSql = realloc( zSql, nSql + len + 4 ); - if( zSql==0 ){ - fprintf(stderr,"Error: out of memory\n"); - exit(1); - } - zSql[nSql++] = '\n'; - memcpy(&zSql[nSql], zLine, len+1); - nSql += len; - } - if( zSql && _contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior) - && sqlite3_complete(zSql) ){ - p->cnt = 0; - open_db(p); - BEGIN_TIMER; - rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg); - END_TIMER; - if( rc || zErrMsg ){ - char zPrefix[100]; - if( in!=0 || !stdin_is_interactive ){ - sqlite3_snprintf(sizeof(zPrefix), zPrefix, - "Error: near line %d:", startline); - }else{ - sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:"); - } - if( zErrMsg!=0 ){ - fprintf(stderr, "%s %s\n", zPrefix, zErrMsg); - sqlite3_free(zErrMsg); - zErrMsg = 0; - }else{ - fprintf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db)); - } - errCnt++; - } - free(zSql); - zSql = 0; - nSql = 0; - } - } - if( zSql ){ - if( !_all_whitespace(zSql) ) fprintf(stderr, "Error: incomplete SQL: %s\n", zSql); - free(zSql); - } - free(zLine); - return errCnt; -} - -/* -** Return a pathname which is the user's home directory. A -** 0 return indicates an error of some kind. Space to hold the -** resulting string is obtained from malloc(). The calling -** function should free the result. -*/ -static char *find_home_dir(void){ - char *home_dir = NULL; - -#if !defined(_WIN32) && !defined(WIN32) && !defined(__OS2__) && !defined(_WIN32_WCE) && !defined(__RTP__) && !defined(_WRS_KERNEL) - struct passwd *pwent; - uid_t uid = getuid(); - if( (pwent=getpwuid(uid)) != NULL) { - home_dir = pwent->pw_dir; - } -#endif - -#if defined(_WIN32_WCE) - /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv() - */ - home_dir = strdup("/"); -#else - -#if defined(_WIN32) || defined(WIN32) || defined(__OS2__) - if (!home_dir) { - home_dir = getenv("USERPROFILE"); - } -#endif - - if (!home_dir) { - home_dir = getenv("HOME"); - } - -#if defined(_WIN32) || defined(WIN32) || defined(__OS2__) - if (!home_dir) { - char *zDrive, *zPath; - int n; - zDrive = getenv("HOMEDRIVE"); - zPath = getenv("HOMEPATH"); - if( zDrive && zPath ){ - n = strlen30(zDrive) + strlen30(zPath) + 1; - home_dir = malloc( n ); - if( home_dir==0 ) return 0; - sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath); - return home_dir; - } - home_dir = "c:\\"; - } -#endif - -#endif /* !_WIN32_WCE */ - - if( home_dir ){ - int n = strlen30(home_dir) + 1; - char *z = malloc( n ); - if( z ) memcpy(z, home_dir, n); - home_dir = z; - } - - return home_dir; -} - -/* -** Read input from the file given by sqliterc_override. Or if that -** parameter is NULL, take input from ~/.sqliterc -** -** Returns the number of errors. -*/ -static int process_sqliterc( - struct callback_data *p, /* Configuration data */ - const char *sqliterc_override /* Name of config file. NULL to use default */ -){ - char *home_dir = NULL; - const char *sqliterc = sqliterc_override; - char *zBuf = 0; - FILE *in = NULL; - int nBuf; - int rc = 0; - - if (sqliterc == NULL) { - home_dir = find_home_dir(); - if( home_dir==0 ){ -#if !defined(__RTP__) && !defined(_WRS_KERNEL) - fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0); -#endif - return 1; - } - nBuf = strlen30(home_dir) + 16; - zBuf = malloc( nBuf ); - if( zBuf==0 ){ - fprintf(stderr,"%s: Error: out of memory\n",Argv0); - return 1; - } - sqlite3_snprintf(nBuf, zBuf,"%s/.sqliterc",home_dir); - free(home_dir); - sqliterc = (const char*)zBuf; - } - in = fopen(sqliterc,"rb"); - if( in ){ - if( stdin_is_interactive ){ - fprintf(stderr,"-- Loading resources from %s\n",sqliterc); - } - rc = process_input(p,in); - fclose(in); - } - free(zBuf); - return rc; -} - -/* -** Show available command line options -*/ -static const char zOptions[] = - " -help show this message\n" - " -init filename read/process named file\n" - " -echo print commands before execution\n" - " -[no]header turn headers on or off\n" - " -bail stop after hitting an error\n" - " -interactive force interactive I/O\n" - " -batch force batch I/O\n" - " -column set output mode to 'column'\n" - " -csv set output mode to 'csv'\n" - " -html set output mode to HTML\n" - " -line set output mode to 'line'\n" - " -list set output mode to 'list'\n" - " -separator 'x' set output field separator (|)\n" - " -nullvalue 'text' set text string for NULL values\n" - " -version show SQLite version\n" -; -static void usage(int showDetail){ - fprintf(stderr, - "Usage: %s [OPTIONS] FILENAME [SQL]\n" - "FILENAME is the name of an SQLite database. A new database is created\n" - "if the file does not previously exist.\n", Argv0); - if( showDetail ){ - fprintf(stderr, "OPTIONS include:\n%s", zOptions); - }else{ - fprintf(stderr, "Use the -help option for additional information\n"); - } - exit(1); -} - -/* -** Initialize the state information in data -*/ -static void main_init(struct callback_data *data) { - memset(data, 0, sizeof(*data)); - data->mode = MODE_List; - memcpy(data->separator,"|", 2); - data->showHeader = 0; - sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data); - sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> "); - sqlite3_snprintf(sizeof(continuePrompt), continuePrompt," ...> "); - sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); -} - -int main(int argc, char **argv){ - char *zErrMsg = 0; - struct callback_data data; - const char *zInitFile = 0; - char *zFirstCmd = 0; - int i; - int rc = 0; - - Argv0 = argv[0]; - main_init(&data); - stdin_is_interactive = isatty(0); - - /* Make sure we have a valid signal handler early, before anything - ** else is done. - */ -#ifdef SIGINT - signal(SIGINT, interrupt_handler); -#endif - - /* Do an initial pass through the command-line argument to locate - ** the name of the database file, the name of the initialization file, - ** and the first command to execute. - */ - for(i=1; i0 ){ - return rc; - } - - /* Make a second pass through the command-line argument and set - ** options. This second pass is delayed until after the initialization - ** file is processed so that the command-line arguments will override - ** settings in the initialization file. - */ - for(i=1; i=argc){ - fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - sqlite3_snprintf(sizeof(data.separator), data.separator, - "%.*s",(int)sizeof(data.separator)-1,argv[i]); - }else if( strcmp(z,"-nullvalue")==0 ){ - i++; - if(i>=argc){ - fprintf(stderr,"%s: Error: missing argument for option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue, - "%.*s",(int)sizeof(data.nullvalue)-1,argv[i]); - }else if( strcmp(z,"-header")==0 ){ - data.showHeader = 1; - }else if( strcmp(z,"-noheader")==0 ){ - data.showHeader = 0; - }else if( strcmp(z,"-echo")==0 ){ - data.echoOn = 1; - }else if( strcmp(z,"-bail")==0 ){ - bail_on_error = 1; - }else if( strcmp(z,"-version")==0 ){ - printf("%s\n", sqlite3_libversion()); - return 0; - }else if( strcmp(z,"-interactive")==0 ){ - stdin_is_interactive = 1; - }else if( strcmp(z,"-batch")==0 ){ - stdin_is_interactive = 0; - }else if( strcmp(z,"-help")==0 || strcmp(z, "--help")==0 ){ - usage(1); - }else{ - fprintf(stderr,"%s: Error: unknown option: %s\n", Argv0, z); - fprintf(stderr,"Use -help for a list of options.\n"); - return 1; - } - } - - if( zFirstCmd ){ - /* Run just the command that follows the database name - */ - if( zFirstCmd[0]=='.' ){ - rc = do_meta_command(zFirstCmd, &data); - return rc; - }else{ - open_db(&data); - rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg); - if( zErrMsg!=0 ){ - fprintf(stderr,"Error: %s\n", zErrMsg); - return rc!=0 ? rc : 1; - }else if( rc!=0 ){ - fprintf(stderr,"Error: unable to process SQL \"%s\"\n", zFirstCmd); - return rc; - } - } - }else{ - /* Run commands received from standard input - */ - if( stdin_is_interactive ){ - char *zHome; - char *zHistory = 0; - int nHistory; - printf( - "SQLite version %s\n" - "Enter \".help\" for instructions\n" - "Enter SQL statements terminated with a \";\"\n", - sqlite3_libversion() - ); - zHome = find_home_dir(); - if( zHome ){ - nHistory = strlen30(zHome) + 20; - if( (zHistory = malloc(nHistory))!=0 ){ - sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome); - } - } -#if defined(HAVE_READLINE) && HAVE_READLINE==1 - if( zHistory ) read_history(zHistory); -#endif - rc = process_input(&data, 0); - if( zHistory ){ - stifle_history(100); - write_history(zHistory); - free(zHistory); - } - free(zHome); - }else{ - rc = process_input(&data, stdin); - } - } - set_table_name(&data, 0); - if( db ){ - if( sqlite3_close(db)!=SQLITE_OK ){ - fprintf(stderr,"Error: cannot close database \"%s\"\n", sqlite3_errmsg(db)); - rc++; - } - } - return rc; -} diff --git a/win64/sqlite/sqlite3.c b/win64/sqlite/sqlite3.c deleted file mode 100644 index 4db4846..0000000 --- a/win64/sqlite/sqlite3.c +++ /dev/null @@ -1,112444 +0,0 @@ -/****************************************************************************** -** This file is an amalgamation of many separate C source files from SQLite -** version 3.6.23.1. By combining all the individual C code files into this -** single large file, the entire code can be compiled as a one translation -** unit. This allows many compilers to do optimizations that would not be -** possible if the files were compiled separately. Performance improvements -** of 5% are more are commonly seen when SQLite is compiled as a single -** translation unit. -** -** This file is all you need to compile SQLite. To use SQLite in other -** programs, you need this file and the "sqlite3.h" header file that defines -** the programming interface to the SQLite library. (If you do not have -** the "sqlite3.h" header file at hand, you will find a copy embedded within -** the text of this file. Search for "Begin file sqlite3.h" to find the start -** of the embedded sqlite3.h header file.) Additional code files may be needed -** if you want a wrapper to interface SQLite with your choice of programming -** language. The code for the "sqlite3" command-line shell is also in a -** separate file. This file contains only code for the core SQLite library. -*/ -#define SQLITE_CORE 1 -#define SQLITE_AMALGAMATION 1 -#ifndef SQLITE_PRIVATE -# define SQLITE_PRIVATE static -#endif -#ifndef SQLITE_API -# define SQLITE_API -#endif -/************** Begin file sqliteInt.h ***************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** Internal interface definitions for SQLite. -** -*/ -#ifndef _SQLITEINT_H_ -#define _SQLITEINT_H_ - -/* -** These #defines should enable >2GB file support on POSIX if the -** underlying operating system supports it. If the OS lacks -** large file support, or if the OS is windows, these should be no-ops. -** -** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any -** system #includes. Hence, this block of code must be the very first -** code in all source files. -** -** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch -** on the compiler command line. This is necessary if you are compiling -** on a recent machine (ex: Red Hat 7.2) but you want your code to work -** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 -** without this option, LFS is enable. But LFS does not exist in the kernel -** in Red Hat 6.0, so the code won't work. Hence, for maximum binary -** portability you should omit LFS. -** -** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. -*/ -#ifndef SQLITE_DISABLE_LFS -# define _LARGE_FILE 1 -# ifndef _FILE_OFFSET_BITS -# define _FILE_OFFSET_BITS 64 -# endif -# define _LARGEFILE_SOURCE 1 -#endif - -/* -** Include the configuration header output by 'configure' if we're using the -** autoconf-based build -*/ -#ifdef _HAVE_SQLITE_CONFIG_H -#include "config.h" -#endif - -/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ -/************** Begin file sqliteLimit.h *************************************/ -/* -** 2007 May 7 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** -** This file defines various limits of what SQLite can process. -*/ - -/* -** The maximum length of a TEXT or BLOB in bytes. This also -** limits the size of a row in a table or index. -** -** The hard limit is the ability of a 32-bit signed integer -** to count the size: 2^31-1 or 2147483647. -*/ -#ifndef SQLITE_MAX_LENGTH -# define SQLITE_MAX_LENGTH 1000000000 -#endif - -/* -** This is the maximum number of -** -** * Columns in a table -** * Columns in an index -** * Columns in a view -** * Terms in the SET clause of an UPDATE statement -** * Terms in the result set of a SELECT statement -** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. -** * Terms in the VALUES clause of an INSERT statement -** -** The hard upper limit here is 32676. Most database people will -** tell you that in a well-normalized database, you usually should -** not have more than a dozen or so columns in any table. And if -** that is the case, there is no point in having more than a few -** dozen values in any of the other situations described above. -*/ -#ifndef SQLITE_MAX_COLUMN -# define SQLITE_MAX_COLUMN 2000 -#endif - -/* -** The maximum length of a single SQL statement in bytes. -** -** It used to be the case that setting this value to zero would -** turn the limit off. That is no longer true. It is not possible -** to turn this limit off. -*/ -#ifndef SQLITE_MAX_SQL_LENGTH -# define SQLITE_MAX_SQL_LENGTH 1000000000 -#endif - -/* -** The maximum depth of an expression tree. This is limited to -** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might -** want to place more severe limits on the complexity of an -** expression. -** -** A value of 0 used to mean that the limit was not enforced. -** But that is no longer true. The limit is now strictly enforced -** at all times. -*/ -#ifndef SQLITE_MAX_EXPR_DEPTH -# define SQLITE_MAX_EXPR_DEPTH 1000 -#endif - -/* -** The maximum number of terms in a compound SELECT statement. -** The code generator for compound SELECT statements does one -** level of recursion for each term. A stack overflow can result -** if the number of terms is too large. In practice, most SQL -** never has more than 3 or 4 terms. Use a value of 0 to disable -** any limit on the number of terms in a compount SELECT. -*/ -#ifndef SQLITE_MAX_COMPOUND_SELECT -# define SQLITE_MAX_COMPOUND_SELECT 500 -#endif - -/* -** The maximum number of opcodes in a VDBE program. -** Not currently enforced. -*/ -#ifndef SQLITE_MAX_VDBE_OP -# define SQLITE_MAX_VDBE_OP 25000 -#endif - -/* -** The maximum number of arguments to an SQL function. -*/ -#ifndef SQLITE_MAX_FUNCTION_ARG -# define SQLITE_MAX_FUNCTION_ARG 127 -#endif - -/* -** The maximum number of in-memory pages to use for the main database -** table and for temporary tables. The SQLITE_DEFAULT_CACHE_SIZE -*/ -#ifndef SQLITE_DEFAULT_CACHE_SIZE -# define SQLITE_DEFAULT_CACHE_SIZE 2000 -#endif -#ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE -# define SQLITE_DEFAULT_TEMP_CACHE_SIZE 500 -#endif - -/* -** The maximum number of attached databases. This must be between 0 -** and 30. The upper bound on 30 is because a 32-bit integer bitmap -** is used internally to track attached databases. -*/ -#ifndef SQLITE_MAX_ATTACHED -# define SQLITE_MAX_ATTACHED 10 -#endif - - -/* -** The maximum value of a ?nnn wildcard that the parser will accept. -*/ -#ifndef SQLITE_MAX_VARIABLE_NUMBER -# define SQLITE_MAX_VARIABLE_NUMBER 999 -#endif - -/* Maximum page size. The upper bound on this value is 32768. This a limit -** imposed by the necessity of storing the value in a 2-byte unsigned integer -** and the fact that the page size must be a power of 2. -** -** If this limit is changed, then the compiled library is technically -** incompatible with an SQLite library compiled with a different limit. If -** a process operating on a database with a page-size of 65536 bytes -** crashes, then an instance of SQLite compiled with the default page-size -** limit will not be able to rollback the aborted transaction. This could -** lead to database corruption. -*/ -#ifndef SQLITE_MAX_PAGE_SIZE -# define SQLITE_MAX_PAGE_SIZE 32768 -#endif - - -/* -** The default size of a database page. -*/ -#ifndef SQLITE_DEFAULT_PAGE_SIZE -# define SQLITE_DEFAULT_PAGE_SIZE 1024 -#endif -#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE -# undef SQLITE_DEFAULT_PAGE_SIZE -# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE -#endif - -/* -** Ordinarily, if no value is explicitly provided, SQLite creates databases -** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain -** device characteristics (sector-size and atomic write() support), -** SQLite may choose a larger value. This constant is the maximum value -** SQLite will choose on its own. -*/ -#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE -# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 -#endif -#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE -# undef SQLITE_MAX_DEFAULT_PAGE_SIZE -# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE -#endif - - -/* -** Maximum number of pages in one database file. -** -** This is really just the default value for the max_page_count pragma. -** This value can be lowered (or raised) at run-time using that the -** max_page_count macro. -*/ -#ifndef SQLITE_MAX_PAGE_COUNT -# define SQLITE_MAX_PAGE_COUNT 1073741823 -#endif - -/* -** Maximum length (in bytes) of the pattern in a LIKE or GLOB -** operator. -*/ -#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH -# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 -#endif - -/* -** Maximum depth of recursion for triggers. -** -** A value of 1 means that a trigger program will not be able to itself -** fire any triggers. A value of 0 means that no trigger programs at all -** may be executed. -*/ -#ifndef SQLITE_MAX_TRIGGER_DEPTH -# define SQLITE_MAX_TRIGGER_DEPTH 1000 -#endif - -/************** End of sqliteLimit.h *****************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - -/* Disable nuisance warnings on Borland compilers */ -#if defined(__BORLANDC__) -#pragma warn -rch /* unreachable code */ -#pragma warn -ccc /* Condition is always true or false */ -#pragma warn -aus /* Assigned value is never used */ -#pragma warn -csu /* Comparing signed and unsigned */ -#pragma warn -spa /* Suspicious pointer arithmetic */ -#endif - -/* Needed for various definitions... */ -#ifndef _GNU_SOURCE -# define _GNU_SOURCE -#endif - -/* -** Include standard header files as necessary -*/ -#ifdef HAVE_STDINT_H -#include -#endif -#ifdef HAVE_INTTYPES_H -#include -#endif - -/* -** The number of samples of an index that SQLite takes in order to -** construct a histogram of the table content when running ANALYZE -** and with SQLITE_ENABLE_STAT2 -*/ -#define SQLITE_INDEX_SAMPLES 10 - -/* -** The following macros are used to cast pointers to integers and -** integers to pointers. The way you do this varies from one compiler -** to the next, so we have developed the following set of #if statements -** to generate appropriate macros for a wide range of compilers. -** -** The correct "ANSI" way to do this is to use the intptr_t type. -** Unfortunately, that typedef is not available on all compilers, or -** if it is available, it requires an #include of specific headers -** that very from one machine to the next. -** -** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on -** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). -** So we have to define the macros in different ways depending on the -** compiler. -*/ -#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ -# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) -#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ -# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) -# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) -#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ -# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) -#else /* Generates a warning - but it always works */ -# define SQLITE_INT_TO_PTR(X) ((void*)(X)) -# define SQLITE_PTR_TO_INT(X) ((int)(X)) -#endif - -/* -** The SQLITE_THREADSAFE macro must be defined as either 0 or 1. -** Older versions of SQLite used an optional THREADSAFE macro. -** We support that for legacy -*/ -#if !defined(SQLITE_THREADSAFE) -#if defined(THREADSAFE) -# define SQLITE_THREADSAFE THREADSAFE -#else -# define SQLITE_THREADSAFE 1 -#endif -#endif - -/* -** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1. -** It determines whether or not the features related to -** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can -** be overridden at runtime using the sqlite3_config() API. -*/ -#if !defined(SQLITE_DEFAULT_MEMSTATUS) -# define SQLITE_DEFAULT_MEMSTATUS 1 -#endif - -/* -** Exactly one of the following macros must be defined in order to -** specify which memory allocation subsystem to use. -** -** SQLITE_SYSTEM_MALLOC // Use normal system malloc() -** SQLITE_MEMDEBUG // Debugging version of system malloc() -** -** (Historical note: There used to be several other options, but we've -** pared it down to just these two.) -** -** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as -** the default. -*/ -#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)>1 -# error "At most one of the following compile-time configuration options\ - is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG" -#endif -#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)==0 -# define SQLITE_SYSTEM_MALLOC 1 -#endif - -/* -** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the -** sizes of memory allocations below this value where possible. -*/ -#if !defined(SQLITE_MALLOC_SOFT_LIMIT) -# define SQLITE_MALLOC_SOFT_LIMIT 1024 -#endif - -/* -** We need to define _XOPEN_SOURCE as follows in order to enable -** recursive mutexes on most Unix systems. But Mac OS X is different. -** The _XOPEN_SOURCE define causes problems for Mac OS X we are told, -** so it is omitted there. See ticket #2673. -** -** Later we learn that _XOPEN_SOURCE is poorly or incorrectly -** implemented on some systems. So we avoid defining it at all -** if it is already defined or if it is unneeded because we are -** not doing a threadsafe build. Ticket #2681. -** -** See also ticket #2741. -*/ -#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE -# define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */ -#endif - -/* -** The TCL headers are only needed when compiling the TCL bindings. -*/ -#if defined(SQLITE_TCL) || defined(TCLSH) -# include -#endif - -/* -** Many people are failing to set -DNDEBUG=1 when compiling SQLite. -** Setting NDEBUG makes the code smaller and run faster. So the following -** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1 -** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out -** feature. -*/ -#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) -# define NDEBUG 1 -#endif - -/* -** The testcase() macro is used to aid in coverage testing. When -** doing coverage testing, the condition inside the argument to -** testcase() must be evaluated both true and false in order to -** get full branch coverage. The testcase() macro is inserted -** to help ensure adequate test coverage in places where simple -** condition/decision coverage is inadequate. For example, testcase() -** can be used to make sure boundary values are tested. For -** bitmask tests, testcase() can be used to make sure each bit -** is significant and used at least once. On switch statements -** where multiple cases go to the same block of code, testcase() -** can insure that all cases are evaluated. -** -*/ -#ifdef SQLITE_COVERAGE_TEST -SQLITE_PRIVATE void sqlite3Coverage(int); -# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } -#else -# define testcase(X) -#endif - -/* -** The TESTONLY macro is used to enclose variable declarations or -** other bits of code that are needed to support the arguments -** within testcase() and assert() macros. -*/ -#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) -# define TESTONLY(X) X -#else -# define TESTONLY(X) -#endif - -/* -** Sometimes we need a small amount of code such as a variable initialization -** to setup for a later assert() statement. We do not want this code to -** appear when assert() is disabled. The following macro is therefore -** used to contain that setup code. The "VVA" acronym stands for -** "Verification, Validation, and Accreditation". In other words, the -** code within VVA_ONLY() will only run during verification processes. -*/ -#ifndef NDEBUG -# define VVA_ONLY(X) X -#else -# define VVA_ONLY(X) -#endif - -/* -** The ALWAYS and NEVER macros surround boolean expressions which -** are intended to always be true or false, respectively. Such -** expressions could be omitted from the code completely. But they -** are included in a few cases in order to enhance the resilience -** of SQLite to unexpected behavior - to make the code "self-healing" -** or "ductile" rather than being "brittle" and crashing at the first -** hint of unplanned behavior. -** -** In other words, ALWAYS and NEVER are added for defensive code. -** -** When doing coverage testing ALWAYS and NEVER are hard-coded to -** be true and false so that the unreachable code then specify will -** not be counted as untested code. -*/ -#if defined(SQLITE_COVERAGE_TEST) -# define ALWAYS(X) (1) -# define NEVER(X) (0) -#elif !defined(NDEBUG) -# define ALWAYS(X) ((X)?1:(assert(0),0)) -# define NEVER(X) ((X)?(assert(0),1):0) -#else -# define ALWAYS(X) (X) -# define NEVER(X) (X) -#endif - -/* -** The macro unlikely() is a hint that surrounds a boolean -** expression that is usually false. Macro likely() surrounds -** a boolean expression that is usually true. GCC is able to -** use these hints to generate better code, sometimes. -*/ -#if defined(__GNUC__) && 0 -# define likely(X) __builtin_expect((X),1) -# define unlikely(X) __builtin_expect((X),0) -#else -# define likely(X) !!(X) -# define unlikely(X) !!(X) -#endif - -/************** Include sqlite3.h in the middle of sqliteInt.h ***************/ -/************** Begin file sqlite3.h *****************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the SQLite library -** presents to client programs. If a C-function, structure, datatype, -** or constant definition does not appear in this file, then it is -** not a published API of SQLite, is subject to change without -** notice, and should not be referenced by programs that use SQLite. -** -** Some of the definitions that are in this file are marked as -** "experimental". Experimental interfaces are normally new -** features recently added to SQLite. We do not anticipate changes -** to experimental interfaces but reserve the right to make minor changes -** if experience from use "in the wild" suggest such changes are prudent. -** -** The official C-language API documentation for SQLite is derived -** from comments in this file. This file is the authoritative source -** on how SQLite interfaces are suppose to operate. -** -** The name of this file under configuration management is "sqlite.h.in". -** The makefile makes some minor changes to this file (such as inserting -** the version number) and changes its name to "sqlite3.h" as -** part of the build process. -*/ -#ifndef _SQLITE3_H_ -#define _SQLITE3_H_ -#include /* Needed for the definition of va_list */ - -/* -** Make sure we can call this stuff from C++. -*/ -#if 0 -extern "C" { -#endif - - -/* -** Add the ability to override 'extern' -*/ -#ifndef SQLITE_EXTERN -# define SQLITE_EXTERN extern -#endif - -#ifndef SQLITE_API -# define SQLITE_API -#endif - - -/* -** These no-op macros are used in front of interfaces to mark those -** interfaces as either deprecated or experimental. New applications -** should not use deprecated interfaces - they are support for backwards -** compatibility only. Application writers should be aware that -** experimental interfaces are subject to change in point releases. -** -** These macros used to resolve to various kinds of compiler magic that -** would generate warning messages when they were used. But that -** compiler magic ended up generating such a flurry of bug reports -** that we have taken it all out and gone back to using simple -** noop macros. -*/ -#define SQLITE_DEPRECATED -#define SQLITE_EXPERIMENTAL - -/* -** Ensure these symbols were not defined by some previous header file. -*/ -#ifdef SQLITE_VERSION -# undef SQLITE_VERSION -#endif -#ifdef SQLITE_VERSION_NUMBER -# undef SQLITE_VERSION_NUMBER -#endif - -/* -** CAPI3REF: Compile-Time Library Version Numbers -** -** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header -** evaluates to a string literal that is the SQLite version in the -** format "X.Y.Z" where X is the major version number (always 3 for -** SQLite3) and Y is the minor version number and Z is the release number.)^ -** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer -** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same -** numbers used in [SQLITE_VERSION].)^ -** The SQLITE_VERSION_NUMBER for any given release of SQLite will also -** be larger than the release from which it is derived. Either Y will -** be held constant and Z will be incremented or else Y will be incremented -** and Z will be reset to zero. -** -** Since version 3.6.18, SQLite source code has been stored in the -** Fossil configuration management -** system. ^The SQLITE_SOURCE_ID macro evalutes to -** a string which identifies a particular check-in of SQLite -** within its configuration management system. ^The SQLITE_SOURCE_ID -** 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()]. -*/ -#define SQLITE_VERSION "3.6.23.1" -#define SQLITE_VERSION_NUMBER 3006023 -#define SQLITE_SOURCE_ID "2010-03-26 22:28:06 b078b588d617e07886ad156e9f54ade6d823568e" - -/* -** CAPI3REF: Run-Time Library Version Numbers -** KEYWORDS: sqlite3_version, sqlite3_sourceid -** -** These interfaces provide the same information as the [SQLITE_VERSION], -** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros -** but are associated with the library instead of the header file. ^(Cautious -** programmers might include assert() statements in their application to -** verify that values returned by these interfaces match the macros in -** the header, and thus insure that the application is -** compiled with matching library and header files. -** -** 
-** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
-** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
-** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
-**
)^ -** -** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] -** macro. ^The sqlite3_libversion() function returns a pointer to the -** to the sqlite3_version[] string constant. The sqlite3_libversion() -** function is provided for use in DLLs since DLL users usually do not have -** direct access to string constants within the DLL. ^The -** sqlite3_libversion_number() function returns an integer equal to -** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns -** a pointer to a string constant whose value is the same as the -** [SQLITE_SOURCE_ID] C preprocessor macro. -** -** See also: [sqlite_version()] and [sqlite_source_id()]. -*/ -SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; -SQLITE_API const char *sqlite3_libversion(void); -SQLITE_API const char *sqlite3_sourceid(void); -SQLITE_API int sqlite3_libversion_number(void); - -#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS -/* -** CAPI3REF: Run-Time Library Compilation Options Diagnostics -** -** ^The sqlite3_compileoption_used() function returns 0 or 1 -** indicating whether the specified option was defined at -** compile time. ^The SQLITE_ prefix may be omitted from the -** option name passed to sqlite3_compileoption_used(). -** -** ^The sqlite3_compileoption_get() function allows interating -** over the list of options that were defined at compile time by -** returning the N-th compile time option string. ^If N is out of range, -** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ -** prefix is omitted from any strings returned by -** sqlite3_compileoption_get(). -** -** ^Support for the diagnostic functions sqlite3_compileoption_used() -** and sqlite3_compileoption_get() may be omitted by specifing the -** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. -** -** See also: SQL functions [sqlite_compileoption_used()] and -** [sqlite_compileoption_get()] and the [compile_options pragma]. -*/ -SQLITE_API int sqlite3_compileoption_used(const char *zOptName); -SQLITE_API const char *sqlite3_compileoption_get(int N); -#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ - -/* -** CAPI3REF: Test To See If The Library Is Threadsafe -** -** ^The sqlite3_threadsafe() function returns zero if and only if -** SQLite was compiled mutexing code omitted due to the -** [SQLITE_THREADSAFE] compile-time option being set to 0. -** -** SQLite can be compiled with or without mutexes. When -** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes -** are enabled and SQLite is threadsafe. When the -** [SQLITE_THREADSAFE] macro is 0, -** the mutexes are omitted. Without the mutexes, it is not safe -** to use SQLite concurrently from more than one thread. -** -** Enabling mutexes incurs a measurable performance penalty. -** So if speed is of utmost importance, it makes sense to disable -** the mutexes. But for maximum safety, mutexes should be enabled. -** ^The default behavior is for mutexes to be enabled. -** -** This interface can be used by an application to make sure that the -** version of SQLite that it is linking against was compiled with -** the desired setting of the [SQLITE_THREADSAFE] macro. -** -** This interface only reports on the compile-time mutex setting -** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with -** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but -** can be fully or partially disabled using a call to [sqlite3_config()] -** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], -** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the -** sqlite3_threadsafe() function shows only the compile-time setting of -** thread safety, not any run-time changes to that setting made by -** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() -** is unchanged by calls to sqlite3_config().)^ -** -** See the [threading mode] documentation for additional information. -*/ -SQLITE_API int sqlite3_threadsafe(void); - -/* -** CAPI3REF: Database Connection Handle -** KEYWORDS: {database connection} {database connections} -** -** Each open SQLite database is represented by a pointer to an instance of -** the opaque structure named "sqlite3". It is useful to think of an sqlite3 -** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and -** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] -** is its destructor. There are many other interfaces (such as -** [sqlite3_prepare_v2()], [sqlite3_create_function()], and -** [sqlite3_busy_timeout()] to name but three) that are methods on an -** sqlite3 object. -*/ -typedef struct sqlite3 sqlite3; - -/* -** CAPI3REF: 64-Bit Integer Types -** KEYWORDS: sqlite_int64 sqlite_uint64 -** -** Because there is no cross-platform way to specify 64-bit integer types -** SQLite includes typedefs for 64-bit signed and unsigned integers. -** -** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. -** The sqlite_int64 and sqlite_uint64 types are supported for backwards -** compatibility only. -** -** ^The sqlite3_int64 and sqlite_int64 types can store integer values -** between -9223372036854775808 and +9223372036854775807 inclusive. ^The -** sqlite3_uint64 and sqlite_uint64 types can store integer values -** between 0 and +18446744073709551615 inclusive. -*/ -#ifdef SQLITE_INT64_TYPE - typedef SQLITE_INT64_TYPE sqlite_int64; - typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; -#elif defined(_MSC_VER) || defined(__BORLANDC__) - typedef __int64 sqlite_int64; - typedef unsigned __int64 sqlite_uint64; -#else - typedef long long int sqlite_int64; - typedef unsigned long long int sqlite_uint64; -#endif -typedef sqlite_int64 sqlite3_int64; -typedef sqlite_uint64 sqlite3_uint64; - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite3_int64 -#endif - -/* -** CAPI3REF: Closing A Database Connection -** -** ^The sqlite3_close() routine is the destructor for the [sqlite3] object. -** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is -** successfullly destroyed and all associated resources are deallocated. -** -** Applications must [sqlite3_finalize | finalize] all [prepared statements] -** and [sqlite3_blob_close | close] all [BLOB handles] associated with -** the [sqlite3] object prior to attempting to close the object. ^If -** sqlite3_close() is called on a [database connection] that still has -** outstanding [prepared statements] or [BLOB handles], then it returns -** SQLITE_BUSY. -** -** ^If [sqlite3_close()] is invoked while a transaction is open, -** the transaction is automatically rolled back. -** -** The C parameter to [sqlite3_close(C)] must be either a NULL -** pointer or an [sqlite3] object pointer obtained -** from [sqlite3_open()], [sqlite3_open16()], or -** [sqlite3_open_v2()], and not previously closed. -** ^Calling sqlite3_close() with a NULL pointer argument is a -** harmless no-op. -*/ -SQLITE_API int sqlite3_close(sqlite3 *); - -/* -** The type for a callback function. -** This is legacy and deprecated. It is included for historical -** compatibility and is not documented. -*/ -typedef int (*sqlite3_callback)(void*,int,char**, char**); - -/* -** CAPI3REF: One-Step Query Execution Interface -** -** The sqlite3_exec() interface is a convenience wrapper around -** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], -** that allows an application to run multiple statements of SQL -** without having to use a lot of C code. -** -** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, -** semicolon-separate SQL statements passed into its 2nd argument, -** in the context of the [database connection] passed in as its 1st -** argument. ^If the callback function of the 3rd argument to -** sqlite3_exec() is not NULL, then it is invoked for each result row -** coming out of the evaluated SQL statements. ^The 4th argument to -** to sqlite3_exec() is relayed through to the 1st argument of each -** callback invocation. ^If the callback pointer to sqlite3_exec() -** is NULL, then no callback is ever invoked and result rows are -** ignored. -** -** ^If an error occurs while evaluating the SQL statements passed into -** sqlite3_exec(), then execution of the current statement stops and -** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() -** is not NULL then any error message is written into memory obtained -** from [sqlite3_malloc()] and passed back through the 5th parameter. -** To avoid memory leaks, the application should invoke [sqlite3_free()] -** on error message strings returned through the 5th parameter of -** of sqlite3_exec() after the error message string is no longer needed. -** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors -** occur, then sqlite3_exec() sets the pointer in its 5th parameter to -** NULL before returning. -** -** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() -** routine returns SQLITE_ABORT without invoking the callback again and -** without running any subsequent SQL statements. -** -** ^The 2nd argument to the sqlite3_exec() callback function is the -** number of columns in the result. ^The 3rd argument to the sqlite3_exec() -** callback is an array of pointers to strings obtained as if from -** [sqlite3_column_text()], one for each column. ^If an element of a -** result row is NULL then the corresponding string pointer for the -** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the -** sqlite3_exec() callback is an array of pointers to strings where each -** entry represents the name of corresponding result column as obtained -** from [sqlite3_column_name()]. -** -** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer -** to an empty string, or a pointer that contains only whitespace and/or -** SQL comments, then no SQL statements are evaluated and the database -** is not changed. -** -** Restrictions: -** -**
    -**
  • The application must insure that the 1st parameter to sqlite3_exec() -** is a valid and open [database connection]. -**
  • The application must not close [database connection] specified by -** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. -**
  • The application must not modify the SQL statement text passed into -** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. -**
-*/ -SQLITE_API int sqlite3_exec( - sqlite3*, /* An open database */ - const char *sql, /* SQL to be evaluated */ - int (*callback)(void*,int,char**,char**), /* Callback function */ - void *, /* 1st argument to callback */ - char **errmsg /* Error msg written here */ -); - -/* -** CAPI3REF: Result Codes -** KEYWORDS: SQLITE_OK {error code} {error codes} -** KEYWORDS: {result code} {result codes} -** -** Many SQLite functions return an integer result code from the set shown -** here in order to indicates success or failure. -** -** New error codes may be added in future versions of SQLite. -** -** See also: [SQLITE_IOERR_READ | extended result codes] -*/ -#define SQLITE_OK 0 /* Successful result */ -/* beginning-of-error-codes */ -#define SQLITE_ERROR 1 /* SQL error or missing database */ -#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ -#define SQLITE_PERM 3 /* Access permission denied */ -#define SQLITE_ABORT 4 /* Callback routine requested an abort */ -#define SQLITE_BUSY 5 /* The database file is locked */ -#define SQLITE_LOCKED 6 /* A table in the database is locked */ -#define SQLITE_NOMEM 7 /* A malloc() failed */ -#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ -#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ -#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ -#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ -#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ -#define SQLITE_FULL 13 /* Insertion failed because database is full */ -#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ -#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ -#define SQLITE_EMPTY 16 /* Database is empty */ -#define SQLITE_SCHEMA 17 /* The database schema changed */ -#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ -#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ -#define SQLITE_MISMATCH 20 /* Data type mismatch */ -#define SQLITE_MISUSE 21 /* Library used incorrectly */ -#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ -#define SQLITE_AUTH 23 /* Authorization denied */ -#define SQLITE_FORMAT 24 /* Auxiliary database format error */ -#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ -#define SQLITE_NOTADB 26 /* File opened that is not a database file */ -#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ -#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ -/* end-of-error-codes */ - -/* -** CAPI3REF: Extended Result Codes -** KEYWORDS: {extended error code} {extended error codes} -** KEYWORDS: {extended result code} {extended result codes} -** -** In its default configuration, SQLite API routines return one of 26 integer -** [SQLITE_OK | result codes]. However, experience has shown that many of -** these result codes are too coarse-grained. They do not provide as -** much information about problems as programmers might like. In an effort to -** address this, newer versions of SQLite (version 3.3.8 and later) include -** support for additional result codes that provide more detailed information -** about errors. The extended result codes are enabled or disabled -** on a per database connection basis using the -** [sqlite3_extended_result_codes()] API. -** -** Some of the available extended result codes are listed here. -** One may expect the number of extended result codes will be expand -** over time. Software that uses extended result codes should expect -** to see new result codes in future releases of SQLite. -** -** The SQLITE_OK result code will never be extended. It will always -** be exactly zero. -*/ -#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)) -#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) -#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) -#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) -#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) -#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) -#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) -#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) -#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) -#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) -#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) -#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) -#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) -#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) -#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) -#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8) ) - -/* -** CAPI3REF: Flags For File Open Operations -** -** These bit values are intended for use in the -** 3rd parameter to the [sqlite3_open_v2()] interface and -** in the 4th parameter to the xOpen method of the -** [sqlite3_vfs] object. -*/ -#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ -#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ -#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ -#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ -#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ -#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ -#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ -#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ -#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ -#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ -#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ -#define SQLITE_OPEN_NOMUTEX 0x00008000 /* 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 -** -** The xDeviceCapabilities method of the [sqlite3_io_methods] -** object returns an integer which is a vector of the these -** bit values expressing I/O characteristics of the mass storage -** device that holds the file that the [sqlite3_io_methods] -** refers to. -** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -*/ -#define SQLITE_IOCAP_ATOMIC 0x00000001 -#define SQLITE_IOCAP_ATOMIC512 0x00000002 -#define SQLITE_IOCAP_ATOMIC1K 0x00000004 -#define SQLITE_IOCAP_ATOMIC2K 0x00000008 -#define SQLITE_IOCAP_ATOMIC4K 0x00000010 -#define SQLITE_IOCAP_ATOMIC8K 0x00000020 -#define SQLITE_IOCAP_ATOMIC16K 0x00000040 -#define SQLITE_IOCAP_ATOMIC32K 0x00000080 -#define SQLITE_IOCAP_ATOMIC64K 0x00000100 -#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 -#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 - -/* -** CAPI3REF: File Locking Levels -** -** SQLite uses one of these integer values as the second -** argument to calls it makes to the xLock() and xUnlock() methods -** of an [sqlite3_io_methods] object. -*/ -#define SQLITE_LOCK_NONE 0 -#define SQLITE_LOCK_SHARED 1 -#define SQLITE_LOCK_RESERVED 2 -#define SQLITE_LOCK_PENDING 3 -#define SQLITE_LOCK_EXCLUSIVE 4 - -/* -** CAPI3REF: Synchronization Type Flags -** -** When SQLite invokes the xSync() method of an -** [sqlite3_io_methods] object it uses a combination of -** these integer values as the second argument. -** -** When the SQLITE_SYNC_DATAONLY flag is used, it means that the -** sync operation only needs to flush data to mass storage. Inode -** information need not be flushed. If the lower four bits of the flag -** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. -** If the lower four bits equal SQLITE_SYNC_FULL, that means -** to use Mac OS X style fullsync instead of fsync(). -*/ -#define SQLITE_SYNC_NORMAL 0x00002 -#define SQLITE_SYNC_FULL 0x00003 -#define SQLITE_SYNC_DATAONLY 0x00010 - -/* -** CAPI3REF: OS Interface Open File Handle -** -** An [sqlite3_file] object represents an open file in the -** [sqlite3_vfs | OS interface layer]. Individual OS interface -** implementations will -** want to subclass this object by appending additional fields -** for their own use. The pMethods entry is a pointer to an -** [sqlite3_io_methods] object that defines methods for performing -** I/O operations on the open file. -*/ -typedef struct sqlite3_file sqlite3_file; -struct sqlite3_file { - const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ -}; - -/* -** CAPI3REF: OS Interface File Virtual Methods Object -** -** Every file opened by the [sqlite3_vfs] xOpen method populates an -** [sqlite3_file] object (or, more commonly, a subclass of the -** [sqlite3_file] object) with a pointer to an instance of this object. -** This object defines the methods used to perform various operations -** against the open file represented by the [sqlite3_file] object. -** -** If the xOpen method sets the sqlite3_file.pMethods element -** to a non-NULL pointer, then the sqlite3_io_methods.xClose method -** may be invoked even if the xOpen reported that it failed. The -** only way to prevent a call to xClose following a failed xOpen -** is for the xOpen to set the sqlite3_file.pMethods element to NULL. -** -** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or -** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). -** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] -** flag may be ORed in to indicate that only the data of the file -** and not its inode needs to be synced. -** -** The integer values to xLock() and xUnlock() are one of -**
    -**
  • [SQLITE_LOCK_NONE], -**
  • [SQLITE_LOCK_SHARED], -**
  • [SQLITE_LOCK_RESERVED], -**
  • [SQLITE_LOCK_PENDING], or -**
  • [SQLITE_LOCK_EXCLUSIVE]. -**
-** xLock() increases the lock. xUnlock() decreases the lock. -** The xCheckReservedLock() method checks whether any database connection, -** either in this process or in some other process, is holding a RESERVED, -** PENDING, or EXCLUSIVE lock on the file. It returns true -** if such a lock exists and false otherwise. -** -** The xFileControl() method is a generic interface that allows custom -** VFS implementations to directly control an open file using the -** [sqlite3_file_control()] interface. The second "op" argument is an -** integer opcode. The third argument is a generic pointer intended to -** point to a structure that may contain arguments or space in which to -** write return values. Potential uses for xFileControl() might be -** functions to enable blocking locks with timeouts, to change the -** locking strategy (for example to use dot-file locks), to inquire -** about the status of a lock, or to break stale locks. The SQLite -** core reserves all opcodes less than 100 for its own use. -** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. -** Applications that define a custom xFileControl method should use opcodes -** greater than 100 to avoid conflicts. -** -** The xSectorSize() method returns the sector size of the -** device that underlies the file. The sector size is the -** minimum write that can be performed without disturbing -** other bytes in the file. The xDeviceCharacteristics() -** method returns a bit vector describing behaviors of the -** underlying device: -** -**
    -**
  • [SQLITE_IOCAP_ATOMIC] -**
  • [SQLITE_IOCAP_ATOMIC512] -**
  • [SQLITE_IOCAP_ATOMIC1K] -**
  • [SQLITE_IOCAP_ATOMIC2K] -**
  • [SQLITE_IOCAP_ATOMIC4K] -**
  • [SQLITE_IOCAP_ATOMIC8K] -**
  • [SQLITE_IOCAP_ATOMIC16K] -**
  • [SQLITE_IOCAP_ATOMIC32K] -**
  • [SQLITE_IOCAP_ATOMIC64K] -**
  • [SQLITE_IOCAP_SAFE_APPEND] -**
  • [SQLITE_IOCAP_SEQUENTIAL] -**
-** -** The SQLITE_IOCAP_ATOMIC property means that all writes of -** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values -** mean that writes of blocks that are nnn bytes in size and -** are aligned to an address which is an integer multiple of -** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means -** that when data is appended to a file, the data is appended -** first then the size of the file is extended, never the other -** way around. The SQLITE_IOCAP_SEQUENTIAL property means that -** information is written to disk in the same order as calls -** to xWrite(). -** -** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill -** in the unread portions of the buffer with zeros. A VFS that -** fails to zero-fill short reads might seem to work. However, -** failure to zero-fill short reads will eventually lead to -** database corruption. -*/ -typedef struct sqlite3_io_methods sqlite3_io_methods; -struct sqlite3_io_methods { - int iVersion; - int (*xClose)(sqlite3_file*); - int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); - int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); - int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); - int (*xSync)(sqlite3_file*, int flags); - int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); - int (*xLock)(sqlite3_file*, int); - int (*xUnlock)(sqlite3_file*, int); - int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); - int (*xFileControl)(sqlite3_file*, int op, void *pArg); - int (*xSectorSize)(sqlite3_file*); - int (*xDeviceCharacteristics)(sqlite3_file*); - /* Additional methods may be added in future releases */ -}; - -/* -** CAPI3REF: Standard File Control Opcodes -** -** These integer constants are opcodes for the xFileControl method -** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] -** interface. -** -** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This -** opcode causes the xFileControl method to write the current state of -** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], -** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) -** into an integer that the pArg argument points to. This capability -** is used during testing and only needs to be supported when SQLITE_TEST -** is defined. -*/ -#define SQLITE_FCNTL_LOCKSTATE 1 -#define SQLITE_GET_LOCKPROXYFILE 2 -#define SQLITE_SET_LOCKPROXYFILE 3 -#define SQLITE_LAST_ERRNO 4 - -/* -** CAPI3REF: Mutex Handle -** -** The mutex module within SQLite defines [sqlite3_mutex] to be an -** abstract type for a mutex object. The SQLite core never looks -** at the internal representation of an [sqlite3_mutex]. It only -** deals with pointers to the [sqlite3_mutex] object. -** -** Mutexes are created using [sqlite3_mutex_alloc()]. -*/ -typedef struct sqlite3_mutex sqlite3_mutex; - -/* -** CAPI3REF: OS Interface Object -** -** An instance of the sqlite3_vfs object defines the interface between -** the SQLite core and the underlying operating system. The "vfs" -** in the name of the object stands for "virtual file system". -** -** The value of the iVersion field is initially 1 but may be larger in -** future versions of SQLite. Additional fields may be appended to this -** object when the iVersion value is increased. Note that the structure -** of the sqlite3_vfs object changes in the transaction between -** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not -** modified. -** -** The szOsFile field is the size of the subclassed [sqlite3_file] -** structure used by this VFS. mxPathname is the maximum length of -** a pathname in this VFS. -** -** Registered sqlite3_vfs objects are kept on a linked list formed by -** the pNext pointer. The [sqlite3_vfs_register()] -** and [sqlite3_vfs_unregister()] interfaces manage this list -** in a thread-safe way. The [sqlite3_vfs_find()] interface -** searches the list. Neither the application code nor the VFS -** implementation should use the pNext pointer. -** -** The pNext field is the only field in the sqlite3_vfs -** structure that SQLite will ever modify. SQLite will only access -** or modify this field while holding a particular static mutex. -** The application should never modify anything within the sqlite3_vfs -** object once the object has been registered. -** -** The zName field holds the name of the VFS module. The name must -** be unique across all VFS modules. -** -** SQLite will guarantee that the zFilename parameter to xOpen -** is either a NULL pointer or string obtained -** from xFullPathname(). SQLite further guarantees that -** the string will be valid and unchanged until xClose() is -** called. Because of the previous sentence, -** the [sqlite3_file] can safely store a pointer to the -** filename if it needs to remember the filename for some reason. -** If the zFilename parameter is xOpen is a NULL pointer then xOpen -** must invent its own temporary name for the file. Whenever the -** xFilename parameter is NULL it will also be the case that the -** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. -** -** The flags argument to xOpen() includes all bits set in -** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] -** or [sqlite3_open16()] is used, then flags includes at least -** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. -** If xOpen() opens a file read-only then it sets *pOutFlags to -** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. -** -** SQLite will also add one of the following flags to the xOpen() -** call, depending on the object being opened: -** -**
    -**
  • [SQLITE_OPEN_MAIN_DB] -**
  • [SQLITE_OPEN_MAIN_JOURNAL] -**
  • [SQLITE_OPEN_TEMP_DB] -**
  • [SQLITE_OPEN_TEMP_JOURNAL] -**
  • [SQLITE_OPEN_TRANSIENT_DB] -**
  • [SQLITE_OPEN_SUBJOURNAL] -**
  • [SQLITE_OPEN_MASTER_JOURNAL] -**
-** -** The file I/O implementation can use the object type flags to -** change the way it deals with files. For example, an application -** that does not care about crash recovery or rollback might make -** the open of a journal file a no-op. Writes to this journal would -** also be no-ops, and any attempt to read the journal would return -** SQLITE_IOERR. Or the implementation might recognize that a database -** file will be doing page-aligned sector reads and writes in a random -** order and set up its I/O subsystem accordingly. -** -** SQLite might also add one of the following flags to the xOpen method: -** -**
    -**
  • [SQLITE_OPEN_DELETEONCLOSE] -**
  • [SQLITE_OPEN_EXCLUSIVE] -**
-** -** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be -** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE] -** will be set for TEMP databases, journals and for subjournals. -** -** The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction -** with the [SQLITE_OPEN_CREATE] flag, which are both directly -** analogous to the O_EXCL and O_CREAT flags of the POSIX open() -** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the -** SQLITE_OPEN_CREATE, is used to indicate that file should always -** be created, and that it is an error if it already exists. -** It is not used to indicate the file should be opened -** for exclusive access. -** -** At least szOsFile bytes of memory are allocated by SQLite -** to hold the [sqlite3_file] structure passed as the third -** argument to xOpen. The xOpen method does not have to -** allocate the structure; it should just fill it in. Note that -** the xOpen method must set the sqlite3_file.pMethods to either -** a valid [sqlite3_io_methods] object or to NULL. xOpen must do -** this even if the open fails. SQLite expects that the sqlite3_file.pMethods -** element will be valid after xOpen returns regardless of the success -** or failure of the xOpen call. -** -** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] -** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to -** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] -** to test whether a file is at least readable. The file can be a -** directory. -** -** SQLite will always allocate at least mxPathname+1 bytes for the -** output buffer xFullPathname. The exact size of the output buffer -** is also passed as a parameter to both methods. If the output buffer -** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is -** handled as a fatal error by SQLite, vfs implementations should endeavor -** to prevent this by setting mxPathname to a sufficiently large value. -** -** The xRandomness(), xSleep(), and xCurrentTime() interfaces -** are not strictly a part of the filesystem, but they are -** included in the VFS structure for completeness. -** The xRandomness() function attempts to return nBytes bytes -** of good-quality randomness into zOut. The return value is -** the actual number of bytes of randomness obtained. -** The xSleep() method causes the calling thread to sleep for at -** least the number of microseconds given. The xCurrentTime() -** method returns a Julian Day Number for the current date and time. -** -*/ -typedef struct sqlite3_vfs sqlite3_vfs; -struct sqlite3_vfs { - int iVersion; /* Structure version number */ - int szOsFile; /* Size of subclassed sqlite3_file */ - int mxPathname; /* Maximum file pathname length */ - sqlite3_vfs *pNext; /* Next registered VFS */ - const char *zName; /* Name of this virtual file system */ - void *pAppData; /* Pointer to application-specific data */ - int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, - int flags, int *pOutFlags); - int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); - int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); - int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); - void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); - void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); - void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); - void (*xDlClose)(sqlite3_vfs*, void*); - int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); - int (*xSleep)(sqlite3_vfs*, int microseconds); - int (*xCurrentTime)(sqlite3_vfs*, double*); - int (*xGetLastError)(sqlite3_vfs*, int, char *); - /* New fields may be appended in figure versions. The iVersion - ** value will increment whenever this happens. */ -}; - -/* -** CAPI3REF: Flags for the xAccess VFS method -** -** These integer constants can be used as the third parameter to -** the xAccess method of an [sqlite3_vfs] object. They determine -** what kind of permissions the xAccess method is looking for. -** With SQLITE_ACCESS_EXISTS, the xAccess method -** simply checks whether the file exists. -** With SQLITE_ACCESS_READWRITE, the xAccess method -** checks whether the file is both readable and writable. -** With SQLITE_ACCESS_READ, the xAccess method -** checks whether the file is readable. -*/ -#define SQLITE_ACCESS_EXISTS 0 -#define SQLITE_ACCESS_READWRITE 1 -#define SQLITE_ACCESS_READ 2 - -/* -** CAPI3REF: Initialize The SQLite Library -** -** ^The sqlite3_initialize() routine initializes the -** SQLite library. ^The sqlite3_shutdown() routine -** deallocates any resources that were allocated by sqlite3_initialize(). -** These routines are designed to aid in process initialization and -** shutdown on embedded systems. Workstation applications using -** SQLite normally do not need to invoke either of these routines. -** -** A call to sqlite3_initialize() is an "effective" call if it is -** the first time sqlite3_initialize() is invoked during the lifetime of -** the process, or if it is the first time sqlite3_initialize() is invoked -** following a call to sqlite3_shutdown(). ^(Only an effective call -** of sqlite3_initialize() does any initialization. All other calls -** are harmless no-ops.)^ -** -** A call to sqlite3_shutdown() is an "effective" call if it is the first -** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only -** an effective call to sqlite3_shutdown() does any deinitialization. -** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ -** -** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() -** is not. The sqlite3_shutdown() interface must only be called from a -** single thread. All open [database connections] must be closed and all -** other SQLite resources must be deallocated prior to invoking -** sqlite3_shutdown(). -** -** Among other things, ^sqlite3_initialize() will invoke -** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() -** will invoke sqlite3_os_end(). -** -** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. -** ^If for some reason, sqlite3_initialize() is unable to initialize -** the library (perhaps it is unable to allocate a needed resource such -** as a mutex) it returns an [error code] other than [SQLITE_OK]. -** -** ^The sqlite3_initialize() routine is called internally by many other -** SQLite interfaces so that an application usually does not need to -** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] -** calls sqlite3_initialize() so the SQLite library will be automatically -** initialized when [sqlite3_open()] is called if it has not be initialized -** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] -** compile-time option, then the automatic calls to sqlite3_initialize() -** are omitted and the application must call sqlite3_initialize() directly -** prior to using any other SQLite interface. For maximum portability, -** it is recommended that applications always invoke sqlite3_initialize() -** directly prior to using any other SQLite interface. Future releases -** of SQLite may require this. In other words, the behavior exhibited -** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the -** default behavior in some future release of SQLite. -** -** The sqlite3_os_init() routine does operating-system specific -** initialization of the SQLite library. The sqlite3_os_end() -** routine undoes the effect of sqlite3_os_init(). Typical tasks -** performed by these routines include allocation or deallocation -** of static resources, initialization of global variables, -** setting up a default [sqlite3_vfs] module, or setting up -** a default configuration using [sqlite3_config()]. -** -** The application should never invoke either sqlite3_os_init() -** or sqlite3_os_end() directly. The application should only invoke -** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() -** interface is called automatically by sqlite3_initialize() and -** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate -** implementations for sqlite3_os_init() and sqlite3_os_end() -** are built into SQLite when it is compiled for Unix, Windows, or OS/2. -** When [custom builds | built for other platforms] -** (using the [SQLITE_OS_OTHER=1] compile-time -** option) the application must supply a suitable implementation for -** sqlite3_os_init() and sqlite3_os_end(). An application-supplied -** implementation of sqlite3_os_init() or sqlite3_os_end() -** must return [SQLITE_OK] on success and some other [error code] upon -** failure. -*/ -SQLITE_API int sqlite3_initialize(void); -SQLITE_API int sqlite3_shutdown(void); -SQLITE_API int sqlite3_os_init(void); -SQLITE_API int sqlite3_os_end(void); - -/* -** CAPI3REF: Configuring The SQLite Library -** -** The sqlite3_config() interface is used to make global configuration -** changes to SQLite in order to tune SQLite to the specific needs of -** the application. The default configuration is recommended for most -** applications and so this routine is usually not necessary. It is -** provided to support rare applications with unusual needs. -** -** The sqlite3_config() interface is not threadsafe. The application -** must insure that no other SQLite interfaces are invoked by other -** threads while sqlite3_config() is running. Furthermore, sqlite3_config() -** may only be invoked prior to library initialization using -** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. -** ^If sqlite3_config() is called after [sqlite3_initialize()] and before -** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. -** Note, however, that ^sqlite3_config() can be called as part of the -** implementation of an application-defined [sqlite3_os_init()]. -** -** The first argument to sqlite3_config() is an integer -** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines -** what property of SQLite is to be configured. Subsequent arguments -** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option] -** in the first argument. -** -** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. -** ^If the option is unknown or SQLite is unable to set the option -** then this routine returns a non-zero [error code]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_config(int, ...); - -/* -** CAPI3REF: Configure database connections -** EXPERIMENTAL -** -** The sqlite3_db_config() interface is used to make configuration -** changes to a [database connection]. The interface is similar to -** [sqlite3_config()] except that the changes apply to a single -** [database connection] (specified in the first argument). The -** sqlite3_db_config() interface should only be used immediately after -** the database connection is created using [sqlite3_open()], -** [sqlite3_open16()], or [sqlite3_open_v2()]. -** -** The second argument to sqlite3_db_config(D,V,...) is the -** configuration verb - an integer code that indicates what -** aspect of the [database connection] is being configured. -** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE]. -** New verbs are likely to be added in future releases of SQLite. -** Additional arguments depend on the verb. -** -** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if -** the call is considered successful. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...); - -/* -** CAPI3REF: Memory Allocation Routines -** EXPERIMENTAL -** -** An instance of this object defines the interface between SQLite -** and low-level memory allocation routines. -** -** This object is used in only one place in the SQLite interface. -** A pointer to an instance of this object is the argument to -** [sqlite3_config()] when the configuration option is -** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. -** By creating an instance of this object -** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) -** 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 several [built-in memory allocators] -** that are perfectly adequate for the overwhelming majority of applications -** and that this object is only useful to a tiny minority of applications -** with specialized memory allocation requirements. This object is -** also used during testing of SQLite in order to specify an alternative -** memory allocator that simulates memory out-of-memory conditions in -** order to verify that SQLite recovers gracefully from such -** conditions. -** -** The xMalloc and xFree methods must work like the -** 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 guarantees 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 -** previously obtained from xMalloc or xRealloc. The allocated size -** is always at least as big as the requested size but may be larger. -** -** The xRoundup method returns what would be the allocated size of -** a memory allocation given a particular requested size. Most memory -** 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. -** 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, -** it might allocate any require mutexes or initialize internal data -** structures. The xShutdown method is invoked (indirectly) by -** [sqlite3_shutdown()] and should deallocate any resources acquired -** by xInit. The pAppData pointer is used as the only parameter to -** 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; -struct sqlite3_mem_methods { - void *(*xMalloc)(int); /* Memory allocation function */ - void (*xFree)(void*); /* Free a prior allocation */ - void *(*xRealloc)(void*,int); /* Resize an allocation */ - int (*xSize)(void*); /* Return the size of an allocation */ - int (*xRoundup)(int); /* Round up request size to allocation size */ - int (*xInit)(void*); /* Initialize the memory allocator */ - void (*xShutdown)(void*); /* Deinitialize the memory allocator */ - void *pAppData; /* Argument to xInit() and xShutdown() */ -}; - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** These constants are the available integer configuration options that -** can be passed as the first argument to the [sqlite3_config()] interface. -** -** New configuration options may be added in future releases of SQLite. -** Existing configuration options might be discontinued. Applications -** should check the return code from [sqlite3_config()] to make sure that -** the call worked. The [sqlite3_config()] interface will return a -** non-zero [error code] if a discontinued or unsupported configuration option -** is invoked. -** -**
-**
SQLITE_CONFIG_SINGLETHREAD
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Single-thread. In other words, it disables -** all mutexing and puts SQLite into a mode where it can only be used -** by a single thread. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to change the [threading mode] from its default -** value of Single-thread and so [sqlite3_config()] will return -** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD -** configuration option.
-** -**
SQLITE_CONFIG_MULTITHREAD
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Multi-thread. In other words, it disables -** mutexing on [database connection] and [prepared statement] objects. -** The application is responsible for serializing access to -** [database connections] and [prepared statements]. But other mutexes -** are enabled so that SQLite will be safe to use in a multi-threaded -** environment as long as no two threads attempt to use the same -** [database connection] at the same time. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to set the Multi-thread [threading mode] and -** [sqlite3_config()] will return [SQLITE_ERROR] if called with the -** SQLITE_CONFIG_MULTITHREAD configuration option.
-** -**
SQLITE_CONFIG_SERIALIZED
-**
There are no arguments to this option. ^This option sets the -** [threading mode] to Serialized. In other words, this option enables -** all mutexes including the recursive -** mutexes on [database connection] and [prepared statement] objects. -** In this mode (which is the default when SQLite is compiled with -** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access -** to [database connections] and [prepared statements] so that the -** application is free to use the same [database connection] or the -** same [prepared statement] in different threads at the same time. -** ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** it is not possible to set the Serialized [threading mode] and -** [sqlite3_config()] will return [SQLITE_ERROR] if called with the -** SQLITE_CONFIG_SERIALIZED configuration option.
-** -**
SQLITE_CONFIG_MALLOC
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mem_methods] structure. The argument specifies -** alternative low-level memory allocation routines to be used in place of -** the memory allocation routines built into SQLite.)^ ^SQLite makes -** its own private copy of the content of the [sqlite3_mem_methods] structure -** before the [sqlite3_config()] call returns.
-** -**
SQLITE_CONFIG_GETMALLOC
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods] -** structure is filled with the currently defined memory allocation routines.)^ -** This option can be used to overload the default memory allocation -** routines with a wrapper that simulations memory allocation failure or -** tracks memory usage, for example.
-** -**
SQLITE_CONFIG_MEMSTATUS
-**
^This option takes single argument of type int, interpreted as a -** boolean, which enables or disables the collection of memory allocation -** statistics. ^(When memory allocation statistics are disabled, the -** following SQLite interfaces become non-operational: -**
    -**
  • [sqlite3_memory_used()] -**
  • [sqlite3_memory_highwater()] -**
  • [sqlite3_soft_heap_limit()] -**
  • [sqlite3_status()] -**
)^ -** ^Memory allocation statistics are enabled by default unless SQLite is -** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory -** allocation statistics are disabled by default. -**
-** -**
SQLITE_CONFIG_SCRATCH
-**
^This option specifies a static memory buffer that SQLite can use for -** scratch memory. There are three arguments: A pointer an 8-byte -** aligned memory buffer from which the scrach allocations will be -** drawn, the size of each scratch allocation (sz), -** and the maximum number of scratch allocations (N). The sz -** argument must be a multiple of 16. The sz parameter should be a few bytes -** larger than the actual scratch space required due to internal overhead. -** The first argument must be a pointer to an 8-byte aligned buffer -** of at least sz*N bytes of memory. -** ^SQLite will use no more than one scratch buffer per thread. So -** N should be set to the expected maximum number of threads. ^SQLite will -** never require a scratch buffer that is more than 6 times the database -** page size. ^If SQLite needs needs additional scratch memory beyond -** what is provided by this configuration option, then -** [sqlite3_malloc()] will be used to obtain the memory needed.
-** -**
SQLITE_CONFIG_PAGECACHE
-**
^This option specifies a static memory buffer that SQLite can use for -** the database page cache with the default page cache implemenation. -** This configuration should not be used if an application-define page -** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option. -** There are three arguments to this option: A pointer to 8-byte aligned -** memory, the size of each page buffer (sz), and the number of pages (N). -** The sz argument should be the size of the largest database page -** (a power of two between 512 and 32768) plus a little extra for each -** page header. ^The page header size is 20 to 40 bytes depending on -** the host architecture. ^It is harmless, apart from the wasted memory, -** to make sz a little too large. The first -** argument should point to an allocation of at least sz*N bytes of memory. -** ^SQLite will use the memory provided by the first argument to satisfy its -** memory needs for the first N pages that it adds to cache. ^If additional -** page cache memory is needed beyond what is provided by this option, then -** SQLite goes to [sqlite3_malloc()] for the additional storage space. -** ^The implementation might use one or more of the N buffers to hold -** memory accounting information. The pointer in the first argument must -** be aligned to an 8-byte boundary or subsequent behavior of SQLite -** will be undefined.
-** -**
SQLITE_CONFIG_HEAP
-**
^This option specifies a static memory buffer that SQLite will use -** for all of its dynamic memory allocation needs beyond those provided -** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. -** There are three arguments: An 8-byte aligned pointer to the memory, -** the number of bytes in the memory buffer, and the minimum allocation size. -** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts -** to using its default memory allocator (the system malloc() implementation), -** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the -** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or -** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory -** allocator is engaged to handle all of SQLites memory allocation needs. -** The first pointer (the memory pointer) must be aligned to an 8-byte -** boundary or subsequent behavior of SQLite will be undefined.
-** -**
SQLITE_CONFIG_MUTEX
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mutex_methods] structure. The argument specifies -** alternative low-level mutex routines to be used in place -** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the -** content of the [sqlite3_mutex_methods] structure before the call to -** [sqlite3_config()] returns. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** the entire mutexing subsystem is omitted from the build and hence calls to -** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will -** return [SQLITE_ERROR].
-** -**
SQLITE_CONFIG_GETMUTEX
-**
^(This option takes a single argument which is a pointer to an -** instance of the [sqlite3_mutex_methods] structure. The -** [sqlite3_mutex_methods] -** structure is filled with the currently defined mutex routines.)^ -** This option can be used to overload the default mutex allocation -** routines with a wrapper used to track mutex usage for performance -** profiling or testing, for example. ^If SQLite is compiled with -** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then -** the entire mutexing subsystem is omitted from the build and hence calls to -** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will -** return [SQLITE_ERROR].
-** -**
SQLITE_CONFIG_LOOKASIDE
-**
^(This option takes two arguments that determine the default -** memory allocation for the lookaside memory allocator on each -** [database connection]. The first argument is the -** size of each lookaside buffer slot and the second is the number of -** slots allocated to each database connection.)^ ^(This option sets the -** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] -** verb to [sqlite3_db_config()] can be used to change the lookaside -** configuration on individual connections.)^
-** -**
SQLITE_CONFIG_PCACHE
-**
^(This option takes a single argument which is a pointer to -** an [sqlite3_pcache_methods] object. This object specifies the interface -** to a custom page cache implementation.)^ ^SQLite makes a copy of the -** object and uses it for page cache memory allocations.
-** -**
SQLITE_CONFIG_GETPCACHE
-**
^(This option takes a single argument which is a pointer to an -** [sqlite3_pcache_methods] object. SQLite copies of the current -** page cache implementation into that object.)^
-** -**
-*/ -#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ -#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ -#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ -#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ -#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ -#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ -#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ -#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ -#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ -#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ -#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ -/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ -#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ -#define SQLITE_CONFIG_PCACHE 14 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_GETPCACHE 15 /* sqlite3_pcache_methods* */ -#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ - -/* -** CAPI3REF: Configuration Options -** EXPERIMENTAL -** -** These constants are the available integer configuration options that -** can be passed as the second argument to the [sqlite3_db_config()] interface. -** -** New configuration options may be added in future releases of SQLite. -** Existing configuration options might be discontinued. Applications -** should check the return code from [sqlite3_db_config()] to make sure that -** the call worked. ^The [sqlite3_db_config()] interface will return a -** non-zero [error code] if a discontinued or unsupported configuration option -** is invoked. -** -**
-**
SQLITE_DBCONFIG_LOOKASIDE
-**
^This option takes three additional arguments that determine the -** [lookaside memory allocator] configuration for the [database connection]. -** ^The first argument (the third parameter to [sqlite3_db_config()] is a -** pointer to an memory buffer to use for lookaside memory. -** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb -** may be NULL in which case SQLite will allocate the -** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the -** size of each lookaside buffer slot. ^The third argument is the number of -** 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. The buffer -** must be aligned to an 8-byte boundary. ^If the second argument to -** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally -** rounded down to the next smaller -** multiple of 8. See also: [SQLITE_CONFIG_LOOKASIDE]
-** -**
-*/ -#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ - - -/* -** CAPI3REF: Enable Or Disable Extended Result Codes -** -** ^The sqlite3_extended_result_codes() routine enables or disables the -** [extended result codes] feature of SQLite. ^The extended result -** codes are disabled by default for historical compatibility. -*/ -SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); - -/* -** CAPI3REF: Last Insert Rowid -** -** ^Each entry in an SQLite table has a unique 64-bit signed -** integer key called the [ROWID | "rowid"]. ^The rowid is always available -** as an undeclared column named ROWID, OID, or _ROWID_ as long as those -** names are not also used by explicitly declared columns. ^If -** the table has a column of type [INTEGER PRIMARY KEY] then that column -** is another alias for the rowid. -** -** ^This routine returns the [rowid] of the most recent -** successful [INSERT] into the database from the [database connection] -** in the first argument. ^If no successful [INSERT]s -** have ever occurred on that database connection, zero is returned. -** -** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted -** row is returned by this routine as long as the trigger is running. -** But once the trigger terminates, the value returned by this routine -** reverts to the last value inserted before the trigger fired.)^ -** -** ^An [INSERT] that fails due to a constraint violation is not a -** successful [INSERT] and does not change the value returned by this -** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, -** and INSERT OR ABORT make no changes to the return value of this -** routine when their insertion fails. ^(When INSERT OR REPLACE -** encounters a constraint violation, it does not fail. The -** INSERT continues to completion after deleting rows that caused -** the constraint problem so INSERT OR REPLACE will always change -** the return value of this interface.)^ -** -** ^For the purposes of this routine, an [INSERT] is considered to -** be successful even if it is subsequently rolled back. -** -** This function is accessible to SQL statements via the -** [last_insert_rowid() SQL function]. -** -** If a separate thread performs a new [INSERT] on the same -** database connection while the [sqlite3_last_insert_rowid()] -** function is running and thus changes the last insert [rowid], -** then the value returned by [sqlite3_last_insert_rowid()] is -** unpredictable and might not equal either the old or the new -** last insert [rowid]. -*/ -SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); - -/* -** CAPI3REF: Count The Number Of Rows Modified -** -** ^This function returns the number of database rows that were changed -** or inserted or deleted by the most recently completed SQL statement -** on the [database connection] specified by the first parameter. -** ^(Only changes that are directly specified by the [INSERT], [UPDATE], -** or [DELETE] statement are counted. Auxiliary changes caused by -** triggers or [foreign key actions] are not counted.)^ Use the -** [sqlite3_total_changes()] function to find the total number of changes -** including changes caused by triggers and foreign key actions. -** -** ^Changes to a view that are simulated by an [INSTEAD OF trigger] -** are not counted. Only real table changes are counted. -** -** ^(A "row change" is a change to a single row of a single table -** caused by an INSERT, DELETE, or UPDATE statement. Rows that -** are changed as side effects of [REPLACE] constraint resolution, -** rollback, ABORT processing, [DROP TABLE], or by any other -** mechanisms do not count as direct row changes.)^ -** -** A "trigger context" is a scope of execution that begins and -** ends with the script of a [CREATE TRIGGER | trigger]. -** Most SQL statements are -** evaluated outside of any trigger. This is the "top level" -** trigger context. If a trigger fires from the top level, a -** new trigger context is entered for the duration of that one -** trigger. Subtriggers create subcontexts for their duration. -** -** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does -** not create a new trigger context. -** -** ^This function returns the number of direct row changes in the -** most recent INSERT, UPDATE, or DELETE statement within the same -** trigger context. -** -** ^Thus, when called from the top level, this function returns the -** number of changes in the most recent INSERT, UPDATE, or DELETE -** that also occurred at the top level. ^(Within the body of a trigger, -** the sqlite3_changes() interface can be called to find the number of -** changes in the most recently completed INSERT, UPDATE, or DELETE -** statement within the body of the same trigger. -** However, the number returned does not include changes -** caused by subtriggers since those have their own context.)^ -** -** 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. -*/ -SQLITE_API int sqlite3_changes(sqlite3*); - -/* -** CAPI3REF: Total Number Of Rows Modified -** -** ^This function returns the number of row changes caused by [INSERT], -** [UPDATE] or [DELETE] statements since the [database connection] was opened. -** ^(The count returned by sqlite3_total_changes() includes all changes -** from all [CREATE TRIGGER | trigger] contexts and changes made by -** [foreign key actions]. However, -** the count does not include changes used to implement [REPLACE] constraints, -** do rollbacks or ABORT processing, or [DROP TABLE] processing. The -** count does not include rows of views that fire an [INSTEAD OF trigger], -** though if the INSTEAD OF trigger makes changes of its own, those changes -** are counted.)^ -** ^The sqlite3_total_changes() function counts the changes as soon as -** the statement that makes them is completed (when the statement handle -** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). -** -** See also the [sqlite3_changes()] interface, the -** [count_changes pragma], and the [total_changes() SQL function]. -** -** 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. -*/ -SQLITE_API int sqlite3_total_changes(sqlite3*); - -/* -** CAPI3REF: Interrupt A Long-Running Query -** -** ^This function causes any pending database operation to abort and -** return at its earliest opportunity. This routine is typically -** called in response to a user action such as pressing "Cancel" -** or Ctrl-C where the user wants a long query operation to halt -** immediately. -** -** ^It is safe to call this routine from a thread different from the -** thread that is currently running the database operation. But it -** is not safe to call this routine with a [database connection] that -** is closed or might close before sqlite3_interrupt() returns. -** -** ^If an SQL operation is very nearly finished at the time when -** sqlite3_interrupt() is called, then it might not have an opportunity -** to be interrupted and might continue to completion. -** -** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. -** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE -** that is inside an explicit transaction, then the entire transaction -** will be rolled back automatically. -** -** ^The sqlite3_interrupt(D) call is in effect until all currently running -** SQL statements on [database connection] D complete. ^Any new SQL statements -** that are started after the sqlite3_interrupt() call and before the -** running statements reaches zero are interrupted as if they had been -** running prior to the sqlite3_interrupt() call. ^New SQL statements -** that are started after the running statement count reaches zero are -** not effected by the sqlite3_interrupt(). -** ^A call to sqlite3_interrupt(D) that occurs when there are no running -** SQL statements is a no-op and has no effect on SQL statements -** that are started after the sqlite3_interrupt() call returns. -** -** If the database connection closes while [sqlite3_interrupt()] -** is running then bad things will likely happen. -*/ -SQLITE_API void sqlite3_interrupt(sqlite3*); - -/* -** CAPI3REF: Determine If An SQL Statement Is Complete -** -** These routines are useful during command-line input to determine if the -** currently entered text seems to form a complete SQL statement or -** if additional input is needed before sending the text into -** SQLite for parsing. ^These routines return 1 if the input string -** appears to be a complete SQL statement. ^A statement is judged to be -** complete if it ends with a semicolon token and is not a prefix of a -** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within -** string literals or quoted identifier names or comments are not -** independent tokens (they are part of the token in which they are -** embedded) and thus do not count as a statement terminator. ^Whitespace -** and comments that follow the final semicolon are ignored. -** -** ^These routines return 0 if the statement is incomplete. ^If a -** memory allocation fails, then SQLITE_NOMEM is returned. -** -** ^These routines do not parse the SQL statements thus -** will not detect syntactically incorrect SQL. -** -** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior -** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked -** automatically by sqlite3_complete16(). If that initialization fails, -** then the return value from sqlite3_complete16() will be non-zero -** regardless of whether or not the input SQL is complete.)^ -** -** The input to [sqlite3_complete()] must be a zero-terminated -** UTF-8 string. -** -** The input to [sqlite3_complete16()] must be a zero-terminated -** UTF-16 string in native byte order. -*/ -SQLITE_API int sqlite3_complete(const char *sql); -SQLITE_API int sqlite3_complete16(const void *sql); - -/* -** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors -** -** ^This routine sets a callback function that might be invoked whenever -** an attempt is made to open a database table that another thread -** or process has locked. -** -** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] -** is returned immediately upon encountering the lock. ^If the busy callback -** is not NULL, then the callback might be invoked with two arguments. -** -** ^The first argument to the busy handler is a copy of the void* pointer which -** is the third argument to sqlite3_busy_handler(). ^The second argument to -** the busy handler callback is the number of times that the busy handler has -** been invoked for this locking event. ^If the -** busy callback returns 0, then no additional attempts are made to -** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. -** ^If the callback returns non-zero, then another attempt -** is made to open the database for reading and the cycle repeats. -** -** The presence of a busy handler does not guarantee that it will be invoked -** when there is lock contention. ^If SQLite determines that invoking the busy -** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] -** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler. -** Consider a scenario where one process is holding a read lock that -** it is trying to promote to a reserved lock and -** a second process is holding a reserved lock that it is trying -** to promote to an exclusive lock. The first process cannot proceed -** because it is blocked by the second and the second process cannot -** proceed because it is blocked by the first. If both processes -** invoke the busy handlers, neither will make any progress. Therefore, -** SQLite returns [SQLITE_BUSY] for the first process, hoping that this -** will induce the first process to release its read lock and allow -** the second process to proceed. -** -** ^The default busy callback is NULL. -** -** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] -** when SQLite is in the middle of a large transaction where all the -** changes will not fit into the in-memory cache. SQLite will -** already hold a RESERVED lock on the database file, but it needs -** to promote this lock to EXCLUSIVE so that it can spill cache -** pages into the database file without harm to concurrent -** readers. ^If it is unable to promote the lock, then the in-memory -** cache will be left in an inconsistent state and so the error -** code is promoted from the relatively benign [SQLITE_BUSY] to -** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion -** forces an automatic rollback of the changes. See the -** -** CorruptionFollowingBusyError wiki page for a discussion of why -** this is important. -** -** ^(There can only be a single busy handler defined for each -** [database connection]. Setting a new busy handler clears any -** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] -** will also set or clear the busy handler. -** -** The busy callback should not take any actions which modify the -** database connection that invoked the busy handler. Any such actions -** result in undefined behavior. -** -** A busy handler must not close the database connection -** or [prepared statement] that invoked the busy handler. -*/ -SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); - -/* -** CAPI3REF: Set A Busy Timeout -** -** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps -** for a specified amount of time when a table is locked. ^The handler -** will sleep multiple times until at least "ms" milliseconds of sleeping -** have accumulated. ^After at least "ms" milliseconds of sleeping, -** the handler returns 0 which causes [sqlite3_step()] to return -** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. -** -** ^Calling this routine with an argument less than or equal to zero -** turns off all busy handlers. -** -** ^(There can only be a single busy handler for a particular -** [database connection] any any given moment. If another busy handler -** was defined (using [sqlite3_busy_handler()]) prior to calling -** this routine, that other busy handler is cleared.)^ -*/ -SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); - -/* -** CAPI3REF: Convenience Routines For Running Queries -** -** Definition: A result table is memory data structure created by the -** [sqlite3_get_table()] interface. A result table records the -** complete query results from one or more queries. -** -** The table conceptually has a number of rows and columns. But -** these numbers are not part of the result table itself. These -** numbers are obtained separately. Let N be the number of rows -** and M be the number of columns. -** -** A result table is an array of pointers to zero-terminated UTF-8 strings. -** There are (N+1)*M elements in the array. The first M pointers point -** to zero-terminated strings that contain the names of the columns. -** The remaining entries all point to query results. NULL values result -** in NULL pointers. All other values are in their UTF-8 zero-terminated -** string representation as returned by [sqlite3_column_text()]. -** -** A result table might consist of one or more memory allocations. -** It is not safe to pass a result table directly to [sqlite3_free()]. -** A result table should be deallocated using [sqlite3_free_table()]. -** -** As an example of the result table format, suppose a query result -** is as follows: -** -** 
-**        Name        | Age
-**        -----------------------
-**        Alice       | 43
-**        Bob         | 28
-**        Cindy       | 21
-**
-** -** There are two column (M==2) and three rows (N==3). Thus the -** result table has 8 entries. Suppose the result table is stored -** in an array names azResult. Then azResult holds this content: -** -** 
-**        azResult[0] = "Name";
-**        azResult[1] = "Age";
-**        azResult[2] = "Alice";
-**        azResult[3] = "43";
-**        azResult[4] = "Bob";
-**        azResult[5] = "28";
-**        azResult[6] = "Cindy";
-**        azResult[7] = "21";
-**
-** -** ^The sqlite3_get_table() function evaluates one or more -** semicolon-separated SQL statements in the zero-terminated UTF-8 -** string of its 2nd parameter and returns a result table to the -** pointer given in its 3rd parameter. -** -** After the application has finished with the result from sqlite3_get_table(), -** it should pass the result table pointer to sqlite3_free_table() in order to -** release the memory that was malloced. Because of the way the -** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling -** function must not try to call [sqlite3_free()] directly. Only -** [sqlite3_free_table()] is able to release the memory properly and safely. -** -** ^(The sqlite3_get_table() interface is implemented as a wrapper around -** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access -** to any internal data structures of SQLite. It uses only the public -** interface defined here. As a consequence, errors that occur in the -** wrapper layer outside of the internal [sqlite3_exec()] call are not -** reflected in subsequent calls to [sqlite3_errcode()] or -** [sqlite3_errmsg()].)^ -*/ -SQLITE_API int sqlite3_get_table( - sqlite3 *db, /* An open database */ - const char *zSql, /* SQL to be evaluated */ - char ***pazResult, /* Results of the query */ - int *pnRow, /* Number of result rows written here */ - int *pnColumn, /* Number of result columns written here */ - char **pzErrmsg /* Error msg written here */ -); -SQLITE_API void sqlite3_free_table(char **result); - -/* -** CAPI3REF: Formatted String Printing Functions -** -** These routines are work-alikes of the "printf()" family of functions -** from the standard C library. -** -** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their -** results into memory obtained from [sqlite3_malloc()]. -** The strings returned by these two routines should be -** released by [sqlite3_free()]. ^Both routines return a -** NULL pointer if [sqlite3_malloc()] is unable to allocate enough -** memory to hold the resulting string. -** -** ^(In sqlite3_snprintf() routine is similar to "snprintf()" from -** the standard C library. The result is written into the -** buffer supplied as the second parameter whose size is given by -** the first parameter. Note that the order of the -** first two parameters is reversed from snprintf().)^ This is an -** historical accident that cannot be fixed without breaking -** backwards compatibility. ^(Note also that sqlite3_snprintf() -** returns a pointer to its buffer instead of the number of -** characters actually written into the buffer.)^ We admit that -** the number of characters written would be a more useful return -** value but we cannot change the implementation of sqlite3_snprintf() -** now without breaking compatibility. -** -** ^As long as the buffer size is greater than zero, sqlite3_snprintf() -** guarantees that the buffer is always zero-terminated. ^The first -** parameter "n" is the total size of the buffer, including space for -** the zero terminator. So the longest string that can be completely -** written will be n-1 characters. -** -** These routines all implement some additional formatting -** options that are useful for constructing SQL statements. -** All of the usual printf() formatting options apply. In addition, there -** is are "%q", "%Q", and "%z" options. -** -** ^(The %q option works like %s in that it substitutes a null-terminated -** string from the argument list. But %q also doubles every '\'' character. -** %q is designed for use inside a string literal.)^ By doubling each '\'' -** character it escapes that character and allows it to be inserted into -** the string. -** -** For example, assume the string variable zText contains text as follows: -** -** 
-**  char *zText = "It's a happy day!";
-**
-** -** One can use this text in an SQL statement as follows: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** Because the %q format string is used, the '\'' character in zText -** is escaped and the SQL generated is as follows: -** -** 
-**  INSERT INTO table1 VALUES('It''s a happy day!')
-**
-** -** This is correct. Had we used %s instead of %q, the generated SQL -** would have looked like this: -** -** 
-**  INSERT INTO table1 VALUES('It's a happy day!');
-**
-** -** This second example is an SQL syntax error. As a general rule you should -** always use %q instead of %s when inserting text into a string literal. -** -** ^(The %Q option works like %q except it also adds single quotes around -** the outside of the total string. Additionally, if the parameter in the -** argument list is a NULL pointer, %Q substitutes the text "NULL" (without -** single quotes).)^ So, for example, one could say: -** -** 
-**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
-**  sqlite3_exec(db, zSQL, 0, 0, 0);
-**  sqlite3_free(zSQL);
-**
-** -** The code above will render a correct SQL statement in the zSQL -** variable even if the zText variable is a NULL pointer. -** -** ^(The "%z" formatting option works like "%s" but with the -** addition that after the string has been read and copied into -** the result, [sqlite3_free()] is called on the input string.)^ -*/ -SQLITE_API char *sqlite3_mprintf(const char*,...); -SQLITE_API char *sqlite3_vmprintf(const char*, va_list); -SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); - -/* -** CAPI3REF: Memory Allocation Subsystem -** -** The SQLite core uses these three routines for all of its own -** internal memory allocation needs. "Core" in the previous sentence -** does not include operating-system specific VFS implementation. The -** Windows VFS uses native malloc() and free() for some operations. -** -** ^The sqlite3_malloc() routine returns a pointer to a block -** of memory at least N bytes in length, where N is the parameter. -** ^If sqlite3_malloc() is unable to obtain sufficient free -** memory, it returns a NULL pointer. ^If the parameter N to -** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns -** a NULL pointer. -** -** ^Calling sqlite3_free() with a pointer previously returned -** by sqlite3_malloc() or sqlite3_realloc() releases that memory so -** that it might be reused. ^The sqlite3_free() routine is -** a no-op if is called with a NULL pointer. Passing a NULL pointer -** to sqlite3_free() is harmless. After being freed, memory -** should neither be read nor written. Even reading previously freed -** memory might result in a segmentation fault or other severe error. -** Memory corruption, a segmentation fault, or other severe error -** might result if sqlite3_free() is called with a non-NULL pointer that -** was not obtained from sqlite3_malloc() or sqlite3_realloc(). -** -** ^(The sqlite3_realloc() interface attempts to resize a -** prior memory allocation to be at least N bytes, where N is the -** second parameter. The memory allocation to be resized is the first -** parameter.)^ ^ If the first parameter to sqlite3_realloc() -** is a NULL pointer then its behavior is identical to calling -** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). -** ^If the second parameter to sqlite3_realloc() is zero or -** negative then the behavior is exactly the same as calling -** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). -** ^sqlite3_realloc() returns a pointer to a memory allocation -** of at least N bytes in size or NULL if sufficient memory is unavailable. -** ^If M is the size of the prior allocation, then min(N,M) bytes -** of the prior allocation are copied into the beginning of buffer returned -** by sqlite3_realloc() and the prior allocation is freed. -** ^If sqlite3_realloc() returns NULL, then the prior allocation -** is not freed. -** -** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() -** is always aligned to at least an 8 byte boundary. -** -** In SQLite version 3.5.0 and 3.5.1, it was possible to define -** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in -** implementation of these routines to be omitted. That capability -** is no longer provided. Only built-in memory allocators can be used. -** -** The Windows OS interface layer calls -** the system malloc() and free() directly when converting -** filenames between the UTF-8 encoding used by SQLite -** and whatever filename encoding is used by the particular Windows -** installation. Memory allocation errors are detected, but -** they are reported back as [SQLITE_CANTOPEN] or -** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. -** -** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] -** must be either NULL or else pointers obtained from a prior -** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have -** not yet been released. -** -** The application must not read or write any part of -** a block of memory after it has been released using -** [sqlite3_free()] or [sqlite3_realloc()]. -*/ -SQLITE_API void *sqlite3_malloc(int); -SQLITE_API void *sqlite3_realloc(void*, int); -SQLITE_API void sqlite3_free(void*); - -/* -** CAPI3REF: Memory Allocator Statistics -** -** SQLite provides these two interfaces for reporting on the status -** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] -** routines, which form the built-in memory allocation subsystem. -** -** ^The [sqlite3_memory_used()] routine returns the number of bytes -** of memory currently outstanding (malloced but not freed). -** ^The [sqlite3_memory_highwater()] routine returns the maximum -** value of [sqlite3_memory_used()] since the high-water mark -** was last reset. ^The values returned by [sqlite3_memory_used()] and -** [sqlite3_memory_highwater()] include any overhead -** added by SQLite in its implementation of [sqlite3_malloc()], -** but not overhead added by the any underlying system library -** routines that [sqlite3_malloc()] may call. -** -** ^The memory high-water mark is reset to the current value of -** [sqlite3_memory_used()] if and only if the parameter to -** [sqlite3_memory_highwater()] is true. ^The value returned -** by [sqlite3_memory_highwater(1)] is the high-water mark -** prior to the reset. -*/ -SQLITE_API sqlite3_int64 sqlite3_memory_used(void); -SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); - -/* -** CAPI3REF: Pseudo-Random Number Generator -** -** SQLite contains a high-quality pseudo-random number generator (PRNG) used to -** select random [ROWID | ROWIDs] when inserting new records into a table that -** already uses the largest possible [ROWID]. The PRNG is also used for -** the build-in random() and randomblob() SQL functions. This interface allows -** applications to access the same PRNG for other purposes. -** -** ^A call to this routine stores N bytes of randomness into buffer P. -** -** ^The first time this routine is invoked (either internally or by -** the application) the PRNG is seeded using randomness obtained -** from the xRandomness method of the default [sqlite3_vfs] object. -** ^On all subsequent invocations, the pseudo-randomness is generated -** internally and without recourse to the [sqlite3_vfs] xRandomness -** method. -*/ -SQLITE_API void sqlite3_randomness(int N, void *P); - -/* -** CAPI3REF: Compile-Time Authorization Callbacks -** -** ^This routine registers a authorizer callback with a particular -** [database connection], supplied in the first argument. -** ^The authorizer callback is invoked as SQL statements are being compiled -** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], -** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various -** points during the compilation process, as logic is being created -** to perform various actions, the authorizer callback is invoked to -** see if those actions are allowed. ^The authorizer callback should -** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the -** specific action but allow the SQL statement to continue to be -** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be -** rejected with an error. ^If the authorizer callback returns -** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] -** then the [sqlite3_prepare_v2()] or equivalent call that triggered -** the authorizer will fail with an error message. -** -** When the callback returns [SQLITE_OK], that means the operation -** requested is ok. ^When the callback returns [SQLITE_DENY], the -** [sqlite3_prepare_v2()] or equivalent call that triggered the -** authorizer will fail with an error message explaining that -** access is denied. -** -** ^The first parameter to the authorizer callback is a copy of the third -** parameter to the sqlite3_set_authorizer() interface. ^The second parameter -** to the callback is an integer [SQLITE_COPY | action code] that specifies -** the particular action to be authorized. ^The third through sixth parameters -** to the callback are zero-terminated strings that contain additional -** details about the action to be authorized. -** -** ^If the action code is [SQLITE_READ] -** and the callback returns [SQLITE_IGNORE] then the -** [prepared statement] statement is constructed to substitute -** a NULL value in place of the table column that would have -** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] -** return can be used to deny an untrusted user access to individual -** columns of a table. -** ^If the action code is [SQLITE_DELETE] and the callback returns -** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the -** [truncate optimization] is disabled and all rows are deleted individually. -** -** An authorizer is used when [sqlite3_prepare | preparing] -** SQL statements from an untrusted source, to ensure that the SQL statements -** do not try to access data they are not allowed to see, or that they do not -** try to execute malicious statements that damage the database. For -** example, an application may allow a user to enter arbitrary -** SQL queries for evaluation by a database. But the application does -** not want the user to be able to make arbitrary changes to the -** database. An authorizer could then be put in place while the -** user-entered SQL is being [sqlite3_prepare | prepared] that -** disallows everything except [SELECT] statements. -** -** Applications that need to process SQL from untrusted sources -** might also consider lowering resource limits using [sqlite3_limit()] -** and limiting database size using the [max_page_count] [PRAGMA] -** in addition to using an authorizer. -** -** ^(Only a single authorizer can be in place on a database connection -** at a time. Each call to sqlite3_set_authorizer overrides the -** previous call.)^ ^Disable the authorizer by installing a NULL callback. -** The authorizer is disabled by default. -** -** The authorizer callback must not do anything that will modify -** the database connection that invoked the authorizer callback. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the -** statement might be re-prepared during [sqlite3_step()] due to a -** schema change. Hence, the application should ensure that the -** correct authorizer callback remains in place during the [sqlite3_step()]. -** -** ^Note that the authorizer callback is invoked only during -** [sqlite3_prepare()] or its variants. Authorization is not -** performed during statement evaluation in [sqlite3_step()], unless -** as stated in the previous paragraph, sqlite3_step() invokes -** sqlite3_prepare_v2() to reprepare a statement after a schema change. -*/ -SQLITE_API int sqlite3_set_authorizer( - sqlite3*, - int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), - void *pUserData -); - -/* -** CAPI3REF: Authorizer Return Codes -** -** The [sqlite3_set_authorizer | authorizer callback function] must -** return either [SQLITE_OK] or one of these two constants in order -** to signal SQLite whether or not the action is permitted. See the -** [sqlite3_set_authorizer | authorizer documentation] for additional -** information. -*/ -#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ -#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ - -/* -** CAPI3REF: Authorizer Action Codes -** -** The [sqlite3_set_authorizer()] interface registers a callback function -** that is invoked to authorize certain SQL statement actions. The -** second parameter to the callback is an integer code that specifies -** what action is being authorized. These are the integer action codes that -** the authorizer callback may be passed. -** -** These action code values signify what kind of operation is to be -** authorized. The 3rd and 4th parameters to the authorization -** callback function will be parameters or NULL depending on which of these -** codes is used as the second parameter. ^(The 5th parameter to the -** authorizer callback is the name of the database ("main", "temp", -** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback -** is the name of the inner-most trigger or view that is responsible for -** the access attempt or NULL if this access attempt is directly from -** top-level SQL code. -*/ -/******************************************* 3rd ************ 4th ***********/ -#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ -#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ -#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ -#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ -#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ -#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ -#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ -#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ -#define SQLITE_DELETE 9 /* Table Name NULL */ -#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ -#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ -#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ -#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ -#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ -#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ -#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ -#define SQLITE_DROP_VIEW 17 /* View Name NULL */ -#define SQLITE_INSERT 18 /* Table Name NULL */ -#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ -#define SQLITE_READ 20 /* Table Name Column Name */ -#define SQLITE_SELECT 21 /* NULL NULL */ -#define SQLITE_TRANSACTION 22 /* Operation NULL */ -#define SQLITE_UPDATE 23 /* Table Name Column Name */ -#define SQLITE_ATTACH 24 /* Filename NULL */ -#define SQLITE_DETACH 25 /* Database Name NULL */ -#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ -#define SQLITE_REINDEX 27 /* Index Name NULL */ -#define SQLITE_ANALYZE 28 /* Table Name NULL */ -#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ -#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ -#define SQLITE_FUNCTION 31 /* NULL Function Name */ -#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ -#define SQLITE_COPY 0 /* No longer used */ - -/* -** CAPI3REF: Tracing And Profiling Functions -** EXPERIMENTAL -** -** These routines register callback functions that can be used for -** tracing and profiling the execution of SQL statements. -** -** ^The callback function registered by sqlite3_trace() is invoked at -** various times when an SQL statement is being run by [sqlite3_step()]. -** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the -** SQL statement text as the statement first begins executing. -** ^(Additional sqlite3_trace() callbacks might occur -** as each triggered subprogram is entered. The callbacks for triggers -** contain a UTF-8 SQL comment that identifies the trigger.)^ -** -** ^The callback function registered by sqlite3_profile() is invoked -** as each SQL statement finishes. ^The profile callback contains -** the original statement text and an estimate of wall-clock time -** of how long that statement took to run. -*/ -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); -SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, - void(*xProfile)(void*,const char*,sqlite3_uint64), void*); - -/* -** CAPI3REF: Query Progress Callbacks -** -** ^This routine configures a callback function - the -** progress callback - that is invoked periodically during long -** running calls to [sqlite3_exec()], [sqlite3_step()] and -** [sqlite3_get_table()]. An example use for this -** interface is to keep a GUI updated during a large query. -** -** ^If the progress callback returns non-zero, the operation is -** interrupted. This feature can be used to implement a -** "Cancel" button on a GUI progress dialog box. -** -** The progress handler must not do anything that will modify -** the database connection that invoked the progress handler. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -*/ -SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); - -/* -** CAPI3REF: Opening A New Database Connection -** -** ^These routines open an SQLite database file whose name is given by the -** filename argument. ^The filename argument is interpreted as UTF-8 for -** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte -** order for sqlite3_open16(). ^(A [database connection] handle is usually -** returned in *ppDb, even if an error occurs. The only exception is that -** if SQLite is unable to allocate memory to hold the [sqlite3] object, -** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] -** object.)^ ^(If the database is opened (and/or created) successfully, then -** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The -** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain -** an English language description of the error following a failure of any -** of the sqlite3_open() routines. -** -** ^The default encoding for the database will be UTF-8 if -** sqlite3_open() or sqlite3_open_v2() is called and -** UTF-16 in the native byte order if sqlite3_open16() is used. -** -** Whether or not an error occurs when it is opened, resources -** associated with the [database connection] handle should be released by -** passing it to [sqlite3_close()] when it is no longer required. -** -** The sqlite3_open_v2() interface works like sqlite3_open() -** except that it accepts two additional parameters for additional control -** over the new database connection. ^(The flags parameter to -** sqlite3_open_v2() can take one of -** the following three values, optionally combined with the -** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], -** and/or [SQLITE_OPEN_PRIVATECACHE] flags:)^ -** -**
-** ^(
[SQLITE_OPEN_READONLY]
-**
The database is opened in read-only mode. If the database does not -** already exist, an error is returned.
)^ -** -** ^(
[SQLITE_OPEN_READWRITE]
-**
The database is opened for reading and writing if possible, or reading -** only if the file is write protected by the operating system. In either -** case the database must already exist, otherwise an error is returned.
)^ -** -** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
-**
The database is opened for reading and writing, and is creates it if -** it does not already exist. This is the behavior that is always used for -** sqlite3_open() and sqlite3_open16().
)^ -**
-** -** If the 3rd parameter to sqlite3_open_v2() is not one of the -** combinations shown above or one of the combinations shown above combined -** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], -** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags, -** then the behavior is undefined. -** -** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection -** opens in the multi-thread [threading mode] as long as the single-thread -** mode has not been set at compile-time or start-time. ^If the -** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens -** in the serialized [threading mode] unless single-thread was -** 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 -** is created for the connection. ^This in-memory database will vanish when -** the database connection is closed. Future versions of SQLite might -** make use of additional special filenames that begin with the ":" character. -** It is recommended that when a database filename actually does begin with -** a ":" character you should prefix the filename with a pathname such as -** "./" to avoid ambiguity. -** -** ^If the filename is an empty string, then a private, temporary -** on-disk database will be created. ^This private database will be -** automatically deleted as soon as the database connection is closed. -** -** ^The fourth parameter to sqlite3_open_v2() is the name of the -** [sqlite3_vfs] object that defines the operating system interface that -** the new database connection should use. ^If the fourth parameter is -** a NULL pointer then the default [sqlite3_vfs] object is used. -** -** Note to Windows users: The encoding used for the filename argument -** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever -** codepage is currently defined. Filenames containing international -** characters must be converted to UTF-8 prior to passing them into -** sqlite3_open() or sqlite3_open_v2(). -*/ -SQLITE_API int sqlite3_open( - const char *filename, /* Database filename (UTF-8) */ - sqlite3 **ppDb /* OUT: SQLite db handle */ -); -SQLITE_API int sqlite3_open16( - const void *filename, /* Database filename (UTF-16) */ - sqlite3 **ppDb /* OUT: SQLite db handle */ -); -SQLITE_API int sqlite3_open_v2( - const char *filename, /* Database filename (UTF-8) */ - sqlite3 **ppDb, /* OUT: SQLite db handle */ - int flags, /* Flags */ - const char *zVfs /* Name of VFS module to use */ -); - -/* -** CAPI3REF: Error Codes And Messages -** -** ^The sqlite3_errcode() interface returns the numeric [result code] or -** [extended result code] for the most recent failed sqlite3_* API call -** associated with a [database connection]. If a prior API call failed -** but the most recent API call succeeded, 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 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. -** The application does not need to worry about freeing the result. -** However, the error string might be overwritten or deallocated by -** subsequent calls to other SQLite interface functions.)^ -** -** When the serialized [threading mode] is in use, it might be the -** case that a second error occurs on a separate thread in between -** the time of the first error and the call to these interfaces. -** When that happens, the second error will be reported since these -** interfaces always report the most recent result. To avoid -** this, each thread can obtain exclusive use of the [database connection] D -** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning -** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after -** all calls to the interfaces listed here are completed. -** -** If an interface fails with SQLITE_MISUSE, that means the interface -** was invoked incorrectly by the application. In that case, the -** error code and message may or may not be set. -*/ -SQLITE_API int sqlite3_errcode(sqlite3 *db); -SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); -SQLITE_API const char *sqlite3_errmsg(sqlite3*); -SQLITE_API const void *sqlite3_errmsg16(sqlite3*); - -/* -** CAPI3REF: SQL Statement Object -** KEYWORDS: {prepared statement} {prepared statements} -** -** An instance of this object represents a single SQL statement. -** This object is variously known as a "prepared statement" or a -** "compiled SQL statement" or simply as a "statement". -** -** The life of a statement object goes something like this: -** -**
    -**
  1. Create the object using [sqlite3_prepare_v2()] or a related -** function. -**
  2. Bind values to [host parameters] using the sqlite3_bind_*() -** interfaces. -**
  3. Run the SQL by calling [sqlite3_step()] one or more times. -**
  4. Reset the statement using [sqlite3_reset()] then go back -** to step 2. Do this zero or more times. -**
  5. Destroy the object using [sqlite3_finalize()]. -**
-** -** Refer to documentation on individual methods above for additional -** information. -*/ -typedef struct sqlite3_stmt sqlite3_stmt; - -/* -** CAPI3REF: Run-time Limits -** -** ^(This interface allows the size of various constructs to be limited -** on a connection by connection basis. The first parameter is the -** [database connection] whose limit is to be set or queried. The -** second parameter is one of the [limit categories] that define a -** class of constructs to be size limited. The third parameter is the -** new limit for that construct. The function returns the old limit.)^ -** -** ^If the new limit is a negative number, the limit is unchanged. -** ^(For the limit category of SQLITE_LIMIT_XYZ there is a -** [limits | hard upper bound] -** set by a compile-time C preprocessor macro named -** [limits | SQLITE_MAX_XYZ]. -** (The "_LIMIT_" in the name is changed to "_MAX_".))^ -** ^Attempts to increase a limit above its hard upper bound are -** silently truncated to the hard upper bound. -** -** Run-time limits are intended for use in applications that manage -** both their own internal database and also databases that are controlled -** by untrusted external sources. An example application might be a -** web browser that has its own databases for storing history and -** separate databases controlled by JavaScript applications downloaded -** off the Internet. The internal databases can be given the -** large, default limits. Databases managed by external sources can -** be given much smaller limits designed to prevent a denial of service -** attack. Developers might also want to use the [sqlite3_set_authorizer()] -** interface to further control untrusted SQL. The size of the database -** created by an untrusted script can be contained using the -** [max_page_count] [PRAGMA]. -** -** New run-time limit categories may be added in future releases. -*/ -SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); - -/* -** CAPI3REF: Run-Time Limit Categories -** KEYWORDS: {limit category} {*limit categories} -** -** These constants define various performance limits -** that can be lowered at run-time using [sqlite3_limit()]. -** The synopsis of the meanings of the various limits is shown below. -** Additional information is available at [limits | Limits in SQLite]. -** -**
-** ^(
SQLITE_LIMIT_LENGTH
-**
The maximum size of any string or BLOB or table row.
)^ -** -** ^(
SQLITE_LIMIT_SQL_LENGTH
-**
The maximum length of an SQL statement, in bytes.
)^ -** -** ^(
SQLITE_LIMIT_COLUMN
-**
The maximum number of columns in a table definition or in the -** result set of a [SELECT] or the maximum number of columns in an index -** or in an ORDER BY or GROUP BY clause.
)^ -** -** ^(
SQLITE_LIMIT_EXPR_DEPTH
-**
The maximum depth of the parse tree on any expression.
)^ -** -** ^(
SQLITE_LIMIT_COMPOUND_SELECT
-**
The maximum number of terms in a compound SELECT statement.
)^ -** -** ^(
SQLITE_LIMIT_VDBE_OP
-**
The maximum number of instructions in a virtual machine program -** used to implement an SQL statement.
)^ -** -** ^(
SQLITE_LIMIT_FUNCTION_ARG
-**
The maximum number of arguments on a function.
)^ -** -** ^(
SQLITE_LIMIT_ATTACHED
-**
The maximum number of [ATTACH | attached databases].)^
-** -** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
-**
The maximum length of the pattern argument to the [LIKE] or -** [GLOB] operators.
)^ -** -** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
-**
The maximum number of variables in an SQL statement that can -** be bound.
)^ -** -** ^(
SQLITE_LIMIT_TRIGGER_DEPTH
-**
The maximum depth of recursion for triggers.
)^ -**
-*/ -#define SQLITE_LIMIT_LENGTH 0 -#define SQLITE_LIMIT_SQL_LENGTH 1 -#define SQLITE_LIMIT_COLUMN 2 -#define SQLITE_LIMIT_EXPR_DEPTH 3 -#define SQLITE_LIMIT_COMPOUND_SELECT 4 -#define SQLITE_LIMIT_VDBE_OP 5 -#define SQLITE_LIMIT_FUNCTION_ARG 6 -#define SQLITE_LIMIT_ATTACHED 7 -#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 -#define SQLITE_LIMIT_VARIABLE_NUMBER 9 -#define SQLITE_LIMIT_TRIGGER_DEPTH 10 - -/* -** CAPI3REF: Compiling An SQL Statement -** KEYWORDS: {SQL statement compiler} -** -** To execute an SQL query, it must first be compiled into a byte-code -** program using one of these routines. -** -** The first argument, "db", is a [database connection] obtained from a -** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or -** [sqlite3_open16()]. The database connection must not have been closed. -** -** The second argument, "zSql", is the statement to be compiled, encoded -** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() -** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() -** use UTF-16. -** -** ^If the nByte argument is less than zero, then zSql is read up to the -** first zero terminator. ^If nByte is non-negative, then it is the maximum -** number of bytes read from zSql. ^When nByte is non-negative, the -** zSql string ends at either the first '\000' or '\u0000' character or -** the nByte-th byte, whichever comes first. If the caller knows -** that the supplied string is nul-terminated, then there is a small -** performance advantage to be gained by passing an nByte parameter that -** is equal to the number of bytes in the input string including -** the nul-terminator bytes. -** -** ^If pzTail is not NULL then *pzTail is made to point to the first byte -** past the end of the first SQL statement in zSql. These routines only -** compile the first statement in zSql, so *pzTail is left pointing to -** what remains uncompiled. -** -** ^*ppStmt is left pointing to a compiled [prepared statement] that can be -** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set -** to NULL. ^If the input text contains no SQL (if the input is an empty -** string or a comment) then *ppStmt is set to NULL. -** The calling procedure is responsible for deleting the compiled -** SQL statement using [sqlite3_finalize()] after it has finished with it. -** ppStmt may not be NULL. -** -** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; -** otherwise an [error code] is returned. -** -** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are -** recommended for all new programs. The two older interfaces are retained -** for backwards compatibility, but their use is discouraged. -** ^In the "v2" interfaces, the prepared statement -** that is returned (the [sqlite3_stmt] object) contains a copy of the -** original SQL text. This causes the [sqlite3_step()] interface to -** behave differently in three ways: -** -**
    -**
  1. -** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it -** always used to do, [sqlite3_step()] will automatically recompile the SQL -** statement and try to run it again. ^If the schema has changed in -** a way that makes the statement no longer valid, [sqlite3_step()] will still -** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is -** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the -** error go away. Note: use [sqlite3_errmsg()] to find the text -** of the parsing error that results in an [SQLITE_SCHEMA] return. -**
    2. -** -**
  2. -** ^When an error occurs, [sqlite3_step()] will return one of the detailed -** [error codes] or [extended error codes]. ^The legacy behavior was that -** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code -** and the application would have to make a second call to [sqlite3_reset()] -** in order to find the underlying cause of the problem. With the "v2" prepare -** interfaces, the underlying reason for the error is returned immediately. -**
    3. -** -**
  3. -** ^If the value of a [parameter | host parameter] in the WHERE clause might -** change the query plan for a statement, then the statement may be -** automatically recompiled (as if there had been a schema change) on the first -** [sqlite3_step()] call following any change to the -** [sqlite3_bind_text | bindings] of the [parameter]. -**
    4. -**
-*/ -SQLITE_API int sqlite3_prepare( - sqlite3 *db, /* Database handle */ - const char *zSql, /* SQL statement, UTF-8 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const char **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare_v2( - sqlite3 *db, /* Database handle */ - const char *zSql, /* SQL statement, UTF-8 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const char **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare16( - sqlite3 *db, /* Database handle */ - const void *zSql, /* SQL statement, UTF-16 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const void **pzTail /* OUT: Pointer to unused portion of zSql */ -); -SQLITE_API int sqlite3_prepare16_v2( - sqlite3 *db, /* Database handle */ - const void *zSql, /* SQL statement, UTF-16 encoded */ - int nByte, /* Maximum length of zSql in bytes. */ - sqlite3_stmt **ppStmt, /* OUT: Statement handle */ - const void **pzTail /* OUT: Pointer to unused portion of zSql */ -); - -/* -** CAPI3REF: Retrieving Statement SQL -** -** ^This interface can be used to retrieve a saved copy of the original -** SQL text used to create a [prepared statement] if that statement was -** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. -*/ -SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Dynamically Typed Value Object -** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} -** -** SQLite uses the sqlite3_value object to represent all values -** that can be stored in a database table. SQLite uses dynamic typing -** for the values it stores. ^Values stored in sqlite3_value objects -** can be integers, floating point values, strings, BLOBs, or NULL. -** -** An sqlite3_value object may be either "protected" or "unprotected". -** Some interfaces require a protected sqlite3_value. Other interfaces -** will accept either a protected or an unprotected sqlite3_value. -** Every interface that accepts sqlite3_value arguments specifies -** whether or not it requires a protected sqlite3_value. -** -** The terms "protected" and "unprotected" refer to whether or not -** a mutex is held. A internal mutex is held for a protected -** sqlite3_value object but no mutex is held for an unprotected -** sqlite3_value object. If SQLite is compiled to be single-threaded -** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) -** or if SQLite is run in one of reduced mutex modes -** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] -** then there is no distinction between protected and unprotected -** sqlite3_value objects and they can be used interchangeably. However, -** for maximum code portability it is recommended that applications -** still make the distinction between between protected and unprotected -** sqlite3_value objects even when not strictly required. -** -** ^The sqlite3_value objects that are passed as parameters into the -** implementation of [application-defined SQL functions] are protected. -** ^The sqlite3_value object returned by -** [sqlite3_column_value()] is unprotected. -** Unprotected sqlite3_value objects may only be used with -** [sqlite3_result_value()] and [sqlite3_bind_value()]. -** The [sqlite3_value_blob | sqlite3_value_type()] family of -** interfaces require protected sqlite3_value objects. -*/ -typedef struct Mem sqlite3_value; - -/* -** CAPI3REF: SQL Function Context Object -** -** The context in which an SQL function executes is stored in an -** sqlite3_context object. ^A pointer to an sqlite3_context object -** is always first parameter to [application-defined SQL functions]. -** The application-defined SQL function implementation will pass this -** pointer through into calls to [sqlite3_result_int | sqlite3_result()], -** [sqlite3_aggregate_context()], [sqlite3_user_data()], -** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], -** and/or [sqlite3_set_auxdata()]. -*/ -typedef struct sqlite3_context sqlite3_context; - -/* -** CAPI3REF: Binding Values To Prepared Statements -** KEYWORDS: {host parameter} {host parameters} {host parameter name} -** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} -** -** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, -** literals may be replaced by a [parameter] that matches one of following -** templates: -** -**
    -**
  • ? -**
  • ?NNN -**
  • :VVV -**
  • @VVV -**
  • $VVV -**
-** -** In the templates above, NNN represents an integer literal, -** and VVV represents an alphanumeric identifer.)^ ^The values of these -** parameters (also called "host parameter names" or "SQL parameters") -** can be set using the sqlite3_bind_*() routines defined here. -** -** ^The first argument to the sqlite3_bind_*() routines is always -** a pointer to the [sqlite3_stmt] object returned from -** [sqlite3_prepare_v2()] or its variants. -** -** ^The second argument is the index of the SQL parameter to be set. -** ^The leftmost SQL parameter has an index of 1. ^When the same named -** SQL parameter is used more than once, second and subsequent -** occurrences have the same index as the first occurrence. -** ^The index for named parameters can be looked up using the -** [sqlite3_bind_parameter_index()] API if desired. ^The index -** for "?NNN" parameters is the value of NNN. -** ^The NNN value must be between 1 and the [sqlite3_limit()] -** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). -** -** ^The third argument is the value to bind to the parameter. -** -** ^(In those routines that have a fourth argument, its value is the -** number of bytes in the parameter. To be clear: the value is the -** number of bytes in the value, not the number of characters.)^ -** ^If the fourth parameter is negative, the length of the string is -** the number of bytes up to the first zero terminator. -** -** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and -** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or -** string after SQLite has finished with it. ^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. -** ^If the fifth argument has the value [SQLITE_TRANSIENT], then -** SQLite makes its own private copy of the data immediately, before -** the sqlite3_bind_*() routine returns. -** -** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that -** is filled with zeroes. ^A zeroblob uses a fixed amount of memory -** (just an integer to hold its size) while it is being processed. -** Zeroblobs are intended to serve as placeholders for BLOBs whose -** content is later written using -** [sqlite3_blob_open | incremental BLOB I/O] routines. -** ^A negative value for the zeroblob results in a zero-length BLOB. -** -** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer -** for the [prepared statement] or with a prepared statement for which -** [sqlite3_step()] has been called more recently than [sqlite3_reset()], -** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() -** routine is passed a [prepared statement] that has been finalized, the -** result is undefined and probably harmful. -** -** ^Bindings are not cleared by the [sqlite3_reset()] routine. -** ^Unbound parameters are interpreted as NULL. -** -** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an -** [error code] if anything goes wrong. -** ^[SQLITE_RANGE] is returned if the parameter -** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. -** -** See also: [sqlite3_bind_parameter_count()], -** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); -SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); -SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); -SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); -SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); -SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); -SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); -SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); -SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); - -/* -** CAPI3REF: Number Of SQL Parameters -** -** ^This routine can be used to find the number of [SQL parameters] -** in a [prepared statement]. SQL parameters are tokens of the -** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as -** placeholders for values that are [sqlite3_bind_blob | bound] -** to the parameters at a later time. -** -** ^(This routine actually returns the index of the largest (rightmost) -** parameter. For all forms except ?NNN, this will correspond to the -** number of unique parameters. If parameters of the ?NNN form are used, -** there may be gaps in the list.)^ -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_name()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); - -/* -** CAPI3REF: Name Of A Host Parameter -** -** ^The sqlite3_bind_parameter_name(P,N) interface returns -** the name of the N-th [SQL parameter] in the [prepared statement] P. -** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" -** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" -** respectively. -** In other words, the initial ":" or "$" or "@" or "?" -** is included as part of the name.)^ -** ^Parameters of the form "?" without a following integer have no name -** and are referred to as "nameless" or "anonymous parameters". -** -** ^The first host parameter has an index of 1, not 0. -** -** ^If the value N is out of range or if the N-th parameter is -** nameless, then NULL is returned. ^The returned string is -** always in UTF-8 encoding even if the named parameter was -** originally specified as UTF-16 in [sqlite3_prepare16()] or -** [sqlite3_prepare16_v2()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); - -/* -** CAPI3REF: Index Of A Parameter With A Given Name -** -** ^Return the index of an SQL parameter given its name. ^The -** index value returned is suitable for use as the second -** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero -** is returned if no matching parameter is found. ^The parameter -** name must be given in UTF-8 even if the original statement -** was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. -** -** See also: [sqlite3_bind_blob|sqlite3_bind()], -** [sqlite3_bind_parameter_count()], and -** [sqlite3_bind_parameter_index()]. -*/ -SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); - -/* -** CAPI3REF: Reset All Bindings On A Prepared Statement -** -** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset -** the [sqlite3_bind_blob | bindings] on a [prepared statement]. -** ^Use this routine to reset all host parameters to NULL. -*/ -SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); - -/* -** CAPI3REF: Number Of Columns In A Result Set -** -** ^Return the number of columns in the result set returned by the -** [prepared statement]. ^This routine returns 0 if pStmt is an SQL -** statement that does not return data (for example an [UPDATE]). -*/ -SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Column Names In A Result Set -** -** ^These routines return the name assigned to a particular column -** in the result set of a [SELECT] statement. ^The sqlite3_column_name() -** interface returns a pointer to a zero-terminated UTF-8 string -** and sqlite3_column_name16() returns a pointer to a zero-terminated -** UTF-16 string. ^The first parameter is the [prepared statement] -** that implements the [SELECT] statement. ^The second parameter is the -** column number. ^The leftmost column is number 0. -** -** ^The returned string pointer is valid until either the [prepared statement] -** is destroyed by [sqlite3_finalize()] or until the next call to -** sqlite3_column_name() or sqlite3_column_name16() on the same column. -** -** ^If sqlite3_malloc() fails during the processing of either routine -** (for example during a conversion from UTF-8 to UTF-16) then a -** NULL pointer is returned. -** -** ^The name of a result column is the value of the "AS" clause for -** that column, if there is an AS clause. If there is no AS clause -** then the name of the column is unspecified and may change from -** one release of SQLite to the next. -*/ -SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); -SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); - -/* -** CAPI3REF: Source Of Data In A Query Result -** -** ^These routines provide a means to determine the database, table, and -** table column that is the origin of a particular result column in -** [SELECT] statement. -** ^The name of the database or table or column can be returned as -** either a UTF-8 or UTF-16 string. ^The _database_ routines return -** the database name, the _table_ routines return the table name, and -** the origin_ routines return the column name. -** ^The returned string is valid until the [prepared statement] is destroyed -** using [sqlite3_finalize()] or until the same information is requested -** again in a different encoding. -** -** ^The names returned are the original un-aliased names of the -** database, table, and column. -** -** ^The first argument to these interfaces is a [prepared statement]. -** ^These functions return information about the Nth result column returned by -** the statement, where N is the second function argument. -** ^The left-most column is column 0 for these routines. -** -** ^If the Nth column returned by the statement is an expression or -** subquery and is not a column value, then all of these functions return -** NULL. ^These routine might also return NULL if a memory allocation error -** occurs. ^Otherwise, they return the name of the attached database, table, -** or column that query result column was extracted from. -** -** ^As with all other SQLite APIs, those whose names end with "16" return -** UTF-16 encoded strings and the other functions return UTF-8. -** -** ^These APIs are only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. -** -** If two or more threads call one or more of these routines against the same -** prepared statement and column at the same time then the results are -** undefined. -** -** If two or more threads call one or more -** [sqlite3_column_database_name | column metadata interfaces] -** for the same [prepared statement] and result column -** at the same time then the results are undefined. -*/ -SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); -SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); -SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); - -/* -** CAPI3REF: Declared Datatype Of A Query Result -** -** ^(The first parameter is a [prepared statement]. -** If this statement is a [SELECT] statement and the Nth column of the -** returned result set of that [SELECT] is a table column (not an -** expression or subquery) then the declared type of the table -** column is returned.)^ ^If the Nth column of the result set is an -** expression or subquery, then a NULL pointer is returned. -** ^The returned string is always UTF-8 encoded. -** -** ^(For example, given the database schema: -** -** CREATE TABLE t1(c1 VARIANT); -** -** and the following statement to be compiled: -** -** SELECT c1 + 1, c1 FROM t1; -** -** this routine would return the string "VARIANT" for the second result -** column (i==1), and a NULL pointer for the first result column (i==0).)^ -** -** ^SQLite uses dynamic run-time typing. ^So just because a column -** is declared to contain a particular type does not mean that the -** data stored in that column is of the declared type. SQLite is -** strongly typed, but the typing is dynamic not static. ^Type -** is associated with individual values, not with the containers -** used to hold those values. -*/ -SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); -SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); - -/* -** CAPI3REF: Evaluate An SQL Statement -** -** After a [prepared statement] has been prepared using either -** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy -** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function -** must be called one or more times to evaluate the statement. -** -** The details of the behavior of the sqlite3_step() interface depend -** on whether the statement was prepared using the newer "v2" interface -** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy -** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the -** new "v2" interface is recommended for new applications but the legacy -** interface will continue to be supported. -** -** ^In the legacy interface, the return value will be either [SQLITE_BUSY], -** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. -** ^With the "v2" interface, any of the other [result codes] or -** [extended result codes] might be returned as well. -** -** ^[SQLITE_BUSY] means that the database engine was unable to acquire the -** database locks it needs to do its job. ^If the statement is a [COMMIT] -** or occurs outside of an explicit transaction, then you can retry the -** statement. If the statement is not a [COMMIT] and occurs within a -** explicit transaction then you should rollback the transaction before -** continuing. -** -** ^[SQLITE_DONE] means that the statement has finished executing -** successfully. sqlite3_step() should not be called again on this virtual -** machine without first calling [sqlite3_reset()] to reset the virtual -** machine back to its initial state. -** -** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] -** is returned each time a new row of data is ready for processing by the -** caller. The values may be accessed using the [column access functions]. -** sqlite3_step() is called again to retrieve the next row of data. -** -** ^[SQLITE_ERROR] means that a run-time error (such as a constraint -** violation) has occurred. sqlite3_step() should not be called again on -** the VM. More information may be found by calling [sqlite3_errmsg()]. -** ^With the legacy interface, a more specific error code (for example, -** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) -** can be obtained by calling [sqlite3_reset()] on the -** [prepared statement]. ^In the "v2" interface, -** the more specific error code is returned directly by sqlite3_step(). -** -** [SQLITE_MISUSE] means that the this routine was called inappropriately. -** Perhaps it was called on a [prepared statement] that has -** already been [sqlite3_finalize | finalized] or on one that had -** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could -** be the case that the same database connection is being used by two or -** more threads at the same moment in time. -** -** Goofy Interface Alert: In the legacy interface, the sqlite3_step() -** API always returns a generic error code, [SQLITE_ERROR], following any -** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call -** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the -** specific [error codes] that better describes the error. -** We admit that this is a goofy design. The problem has been fixed -** with the "v2" interface. If you prepare all of your SQL statements -** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead -** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, -** then the more specific [error codes] are returned directly -** by sqlite3_step(). The use of the "v2" interface is recommended. -*/ -SQLITE_API int sqlite3_step(sqlite3_stmt*); - -/* -** CAPI3REF: Number of columns in a result set -** -** ^The sqlite3_data_count(P) the number of columns in the -** of the result set of [prepared statement] P. -*/ -SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Fundamental Datatypes -** KEYWORDS: SQLITE_TEXT -** -** ^(Every value in SQLite has one of five fundamental datatypes: -** -**
    -**
  • 64-bit signed integer -**
  • 64-bit IEEE floating point number -**
  • string -**
  • BLOB -**
  • NULL -**
)^ -** -** These constants are codes for each of those types. -** -** Note that the SQLITE_TEXT constant was also used in SQLite version 2 -** for a completely different meaning. Software that links against both -** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not -** SQLITE_TEXT. -*/ -#define SQLITE_INTEGER 1 -#define SQLITE_FLOAT 2 -#define SQLITE_BLOB 4 -#define SQLITE_NULL 5 -#ifdef SQLITE_TEXT -# undef SQLITE_TEXT -#else -# define SQLITE_TEXT 3 -#endif -#define SQLITE3_TEXT 3 - -/* -** CAPI3REF: Result Values From A Query -** KEYWORDS: {column access functions} -** -** These routines form the "result set" interface. -** -** ^These routines return information about a single column of the current -** result row of a query. ^In every case the first argument is a pointer -** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] -** that was returned from [sqlite3_prepare_v2()] or one of its variants) -** and the second argument is the index of the column for which information -** should be returned. ^The leftmost column of the result set has the index 0. -** ^The number of columns in the result can be determined using -** [sqlite3_column_count()]. -** -** If the SQL statement does not currently point to a valid row, or if the -** column index is out of range, the result is undefined. -** These routines may only be called when the most recent call to -** [sqlite3_step()] has returned [SQLITE_ROW] and neither -** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. -** If any of these routines are called after [sqlite3_reset()] or -** [sqlite3_finalize()] or after [sqlite3_step()] has returned -** something other than [SQLITE_ROW], the results are undefined. -** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] -** are called from a different thread while any of these routines -** are pending, then the results are undefined. -** -** ^The sqlite3_column_type() routine returns the -** [SQLITE_INTEGER | datatype code] for the initial data type -** of the result column. ^The returned value is one of [SQLITE_INTEGER], -** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value -** returned by sqlite3_column_type() is only meaningful if no type -** conversions have occurred as described below. After a type conversion, -** the value returned by sqlite3_column_type() is undefined. Future -** versions of SQLite may change the behavior of sqlite3_column_type() -** following a type conversion. -** -** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() -** routine returns the number of bytes in that BLOB or string. -** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts -** the string to UTF-8 and then returns the number of bytes. -** ^If the result is a numeric value then sqlite3_column_bytes() uses -** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns -** the number of bytes in that string. -** ^The value returned does not include the zero terminator at the end -** of the string. ^For clarity: the value returned is the number of -** bytes in the string, not the number of characters. -** -** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), -** even empty strings, are always zero terminated. ^The return -** value from sqlite3_column_blob() for a zero-length BLOB is an arbitrary -** pointer, possibly even a NULL pointer. -** -** ^The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() -** but leaves the result in UTF-16 in native byte order instead of UTF-8. -** ^The zero terminator is not included in this count. -** -** ^The object returned by [sqlite3_column_value()] is an -** [unprotected sqlite3_value] object. An unprotected sqlite3_value object -** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. -** If the [unprotected sqlite3_value] object returned by -** [sqlite3_column_value()] is used in any other way, including calls -** to routines like [sqlite3_value_int()], [sqlite3_value_text()], -** or [sqlite3_value_bytes()], then the behavior is undefined. -** -** These routines attempt to convert the value where appropriate. ^For -** example, if the internal representation is FLOAT and a text result -** is requested, [sqlite3_snprintf()] is used internally to perform the -** conversion automatically. ^(The following table details the conversions -** that are applied: -** -**
-**
-**
Internal
Type 		Requested
Type 		Conversion -** -**
NULL INTEGER Result is 0 -**
NULL FLOAT Result is 0.0 -**
NULL TEXT Result is NULL pointer -**
NULL BLOB Result is NULL pointer -**
INTEGER FLOAT Convert from integer to float -**
INTEGER TEXT ASCII rendering of the integer -**
INTEGER BLOB Same as INTEGER->TEXT -**
FLOAT INTEGER Convert from float to integer -**
FLOAT TEXT ASCII rendering of the float -**
FLOAT BLOB Same as FLOAT->TEXT -**
TEXT INTEGER Use atoi() -**
TEXT FLOAT Use atof() -**
TEXT BLOB No change -**
BLOB INTEGER Convert to TEXT then use atoi() -**
BLOB FLOAT Convert to TEXT then use atof() -**
BLOB TEXT Add a zero terminator if needed -**
-** )^ -** -** The table above makes reference to standard C library functions atoi() -** and atof(). SQLite does not really use these functions. It has its -** own equivalent internal routines. The atoi() and atof() names are -** used in the table for brevity and because they are familiar to most -** C programmers. -** -** ^Note that when type conversions occur, pointers returned by prior -** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or -** sqlite3_column_text16() may be invalidated. -** ^(Type conversions and pointer invalidations might occur -** in the following cases: -** -**
    -**
  • The initial content is a BLOB and sqlite3_column_text() or -** sqlite3_column_text16() is called. A zero-terminator might -** need to be added to the string.
    • -**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or -** sqlite3_column_text16() is called. The content must be converted -** to UTF-16.
    • -**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or -** sqlite3_column_text() is called. The content must be converted -** to UTF-8.
    • -**
)^ -** -** ^Conversions between UTF-16be and UTF-16le are always done in place and do -** not invalidate a prior pointer, though of course the content of the buffer -** that the prior pointer points to will have been modified. Other kinds -** of conversion are done in place when it is possible, but sometimes they -** are not possible and in those cases prior pointers are invalidated. -** -** ^(The safest and easiest to remember policy is to invoke these routines -** in one of the following ways: -** -**
    -**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • -**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • -**
)^ -** -** In other words, you should call sqlite3_column_text(), -** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result -** into the desired format, then invoke sqlite3_column_bytes() or -** sqlite3_column_bytes16() to find the size of the result. Do not mix calls -** to sqlite3_column_text() or sqlite3_column_blob() with calls to -** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() -** with calls to sqlite3_column_bytes(). -** -** ^The pointers returned are valid until a type conversion occurs as -** described above, or until [sqlite3_step()] or [sqlite3_reset()] or -** [sqlite3_finalize()] is called. ^The memory space used to hold strings -** and BLOBs is freed automatically. Do not pass the pointers returned -** [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].)^ -*/ -SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); -SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); -SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); -SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); -SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); -SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); - -/* -** CAPI3REF: Destroy A Prepared Statement Object -** -** ^The sqlite3_finalize() function is called to delete a [prepared statement]. -** ^If the statement was executed successfully or not executed at all, then -** SQLITE_OK is returned. ^If execution of the statement failed then an -** [error code] or [extended error code] is returned. -** -** ^This routine can be called at any point during the execution of the -** [prepared statement]. ^If the virtual machine has not -** completed execution when this routine is called, that is like -** encountering an error or an [sqlite3_interrupt | interrupt]. -** ^Incomplete updates may be rolled back and transactions canceled, -** depending on the circumstances, and the -** [error code] returned will be [SQLITE_ABORT]. -*/ -SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Reset A Prepared Statement Object -** -** The sqlite3_reset() function is called to reset a [prepared statement] -** object back to its initial state, ready to be re-executed. -** ^Any SQL statement variables that had values bound to them using -** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. -** Use [sqlite3_clear_bindings()] to reset the bindings. -** -** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S -** back to the beginning of its program. -** -** ^If the most recent call to [sqlite3_step(S)] for the -** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], -** or if [sqlite3_step(S)] has never before been called on S, -** then [sqlite3_reset(S)] returns [SQLITE_OK]. -** -** ^If the most recent call to [sqlite3_step(S)] for the -** [prepared statement] S indicated an error, then -** [sqlite3_reset(S)] returns an appropriate [error code]. -** -** ^The [sqlite3_reset(S)] interface does not change the values -** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. -*/ -SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Create Or Redefine SQL Functions -** KEYWORDS: {function creation routines} -** KEYWORDS: {application-defined SQL function} -** KEYWORDS: {application-defined SQL functions} -** -** ^These two 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 difference between the -** two is that the second parameter, the name of the (scalar) function or -** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16 -** for sqlite3_create_function16(). -** -** ^The first parameter is the [database connection] to which the SQL -** function is to be added. ^If an application uses more than one database -** connection then application-defined SQL functions must be added -** to each database connection separately. -** -** The second parameter is the name of the SQL function to be created or -** redefined. ^The length of the name is limited to 255 bytes, exclusive of -** the zero-terminator. Note that the name length limit is in bytes, not -** characters. ^Any attempt to create a function with a longer name -** will result in [SQLITE_ERROR] being returned. -** -** ^The third parameter (nArg) -** is the number of arguments that the SQL function or -** aggregate takes. ^If this parameter is -1, then the SQL function or -** aggregate may take any number of arguments between 0 and the limit -** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third -** parameter is less than -1 or greater than 127 then the behavior is -** undefined. -** -** The fourth parameter, eTextRep, specifies what -** [SQLITE_UTF8 | text encoding] this SQL function prefers for -** 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 -** more efficient with one encoding than another. ^An application may -** invoke sqlite3_create_function() or sqlite3_create_function16() multiple -** times with the same function but with different values of eTextRep. -** ^When multiple implementations of the same function are available, SQLite -** will pick the one that involves the least amount of data conversion. -** If there is only a single implementation which does not care what text -** encoding is used, then the fourth argument should be [SQLITE_ANY]. -** -** ^(The fifth parameter is an arbitrary pointer. The implementation of the -** function can gain access to this pointer using [sqlite3_user_data()].)^ -** -** The seventh, eighth and ninth parameters, 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 should be passed as the xStep and xFinal -** parameters. ^An aggregate SQL function requires an implementation of xStep -** and xFinal and NULL should be passed for xFunc. ^To delete an existing -** SQL function or aggregate, pass NULL for all three function callbacks. -** -** ^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 -** the implementation that most closely matches the way in which the -** SQL function is used. ^A function implementation with a non-negative -** nArg parameter is a better match than a function implementation with -** a negative nArg. ^A function where the preferred text encoding -** matches the database encoding is a better -** match than a function where the encoding is different. -** ^A function where the encoding difference is between UTF16le and UTF16be -** is a closer match than a function where the encoding difference is -** between UTF8 and UTF16. -** -** ^Built-in functions may be overloaded by new application-defined functions. -** ^The first application-defined function with a given name overrides all -** built-in functions in the same [database connection] with the same name. -** ^Subsequent application-defined functions of the same name only override -** prior application-defined functions that are an exact match for the -** number of parameters and preferred encoding. -** -** ^An application-defined function is permitted to call other -** SQLite interfaces. However, such calls must not -** close the database connection nor finalize or reset the prepared -** statement in which the function is running. -*/ -SQLITE_API int sqlite3_create_function( - sqlite3 *db, - const char *zFunctionName, - int nArg, - int eTextRep, - void *pApp, - void (*xFunc)(sqlite3_context*,int,sqlite3_value**), - void (*xStep)(sqlite3_context*,int,sqlite3_value**), - void (*xFinal)(sqlite3_context*) -); -SQLITE_API int sqlite3_create_function16( - sqlite3 *db, - const void *zFunctionName, - int nArg, - int eTextRep, - void *pApp, - void (*xFunc)(sqlite3_context*,int,sqlite3_value**), - void (*xStep)(sqlite3_context*,int,sqlite3_value**), - void (*xFinal)(sqlite3_context*) -); - -/* -** CAPI3REF: Text Encodings -** -** These constant define integer codes that represent the various -** text encodings supported by SQLite. -*/ -#define SQLITE_UTF8 1 -#define SQLITE_UTF16LE 2 -#define SQLITE_UTF16BE 3 -#define SQLITE_UTF16 4 /* Use native byte order */ -#define SQLITE_ANY 5 /* sqlite3_create_function only */ -#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ - -/* -** CAPI3REF: Deprecated Functions -** DEPRECATED -** -** These functions are [deprecated]. In order to maintain -** backwards compatibility with older code, these functions continue -** to be supported. However, new applications should avoid -** the use of these functions. To help encourage people to avoid -** using these functions, we are not going to tell you what they do. -*/ -#ifndef SQLITE_OMIT_DEPRECATED -SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); -SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); -SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); -SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); -#endif - -/* -** CAPI3REF: Obtaining SQL Function Parameter Values -** -** The C-language implementation of SQL functions and aggregates uses -** this set of interface routines to access the parameter values on -** the function or aggregate. -** -** The xFunc (for scalar functions) or xStep (for aggregates) parameters -** to [sqlite3_create_function()] and [sqlite3_create_function16()] -** define callbacks that implement the SQL functions and aggregates. -** The 4th parameter to these callbacks is an array of pointers to -** [protected sqlite3_value] objects. There is one [sqlite3_value] object for -** each parameter to the SQL function. These routines are used to -** extract values from the [sqlite3_value] objects. -** -** These routines work only with [protected sqlite3_value] objects. -** Any attempt to use these routines on an [unprotected sqlite3_value] -** object results in undefined behavior. -** -** ^These routines work just like the corresponding [column access functions] -** except that these routines take a single [protected sqlite3_value] object -** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. -** -** ^The sqlite3_value_text16() interface extracts a UTF-16 string -** in the native byte-order of the host machine. ^The -** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces -** extract UTF-16 strings as big-endian and little-endian respectively. -** -** ^(The sqlite3_value_numeric_type() interface attempts to apply -** numeric affinity to the value. This means that an attempt is -** made to convert the value to an integer or floating point. If -** such a conversion is possible without loss of information (in other -** words, if the value is a string that looks like a number) -** then the conversion is performed. Otherwise no conversion occurs. -** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ -** -** 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 -** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], -** or [sqlite3_value_text16()]. -** -** These routines must be called from the same thread as -** the SQL function that supplied the [sqlite3_value*] parameters. -*/ -SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes(sqlite3_value*); -SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); -SQLITE_API double sqlite3_value_double(sqlite3_value*); -SQLITE_API int sqlite3_value_int(sqlite3_value*); -SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); -SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); -SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); -SQLITE_API int sqlite3_value_type(sqlite3_value*); -SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); - -/* -** CAPI3REF: Obtain Aggregate Function Context -** -** Implementions of aggregate SQL functions use this -** routine to allocate memory for storing their state. -** -** ^The first time the sqlite3_aggregate_context(C,N) routine is called -** for a particular aggregate function, SQLite -** allocates N of memory, zeroes out that memory, and returns a pointer -** to the new memory. ^On second and subsequent calls to -** sqlite3_aggregate_context() for the same aggregate function instance, -** the same buffer is returned. Sqlite3_aggregate_context() is normally -** called once for each invocation of the xStep callback and then one -** last time when the xFinal callback is invoked. ^(When no rows match -** an aggregate query, the xStep() callback of the aggregate function -** implementation is never called and xFinal() is called exactly once. -** In those cases, sqlite3_aggregate_context() might be called for the -** first time from within xFinal().)^ -** -** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer if N is -** less than or equal to zero or if a memory allocate error occurs. -** -** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is -** determined by the N parameter on first successful call. Changing the -** value of N in subsequent call to sqlite3_aggregate_context() within -** the same aggregate function instance will not resize the memory -** allocation.)^ -** -** ^SQLite automatically frees the memory allocated by -** sqlite3_aggregate_context() when the aggregate query concludes. -** -** The first parameter must be a copy of the -** [sqlite3_context | SQL function context] that is the first parameter -** to the xStep or xFinal callback routine that implements the aggregate -** function. -** -** This routine must be called from the same thread in which -** the aggregate SQL function is running. -*/ -SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); - -/* -** CAPI3REF: User Data For Functions -** -** ^The sqlite3_user_data() interface returns a copy of -** the pointer that was the pUserData parameter (the 5th parameter) -** of the [sqlite3_create_function()] -** and [sqlite3_create_function16()] routines that originally -** registered the application defined function. -** -** This routine must be called from the same thread in which -** the application-defined function is running. -*/ -SQLITE_API void *sqlite3_user_data(sqlite3_context*); - -/* -** CAPI3REF: Database Connection For Functions -** -** ^The sqlite3_context_db_handle() interface returns a copy of -** the pointer to the [database connection] (the 1st parameter) -** of the [sqlite3_create_function()] -** and [sqlite3_create_function16()] routines that originally -** registered the application defined function. -*/ -SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); - -/* -** CAPI3REF: Function Auxiliary Data -** -** The following two functions may be used by scalar SQL functions to -** associate metadata with argument values. If the same value is passed to -** multiple invocations of the same SQL function during query execution, under -** some circumstances the associated metadata may be preserved. This may -** be used, for example, to add a regular-expression matching scalar -** function. The compiled version of the regular expression is stored as -** metadata associated with the SQL value passed as the regular expression -** pattern. The compiled regular expression can be reused on multiple -** invocations of the same function so that the original pattern string -** does not need to be recompiled on each invocation. -** -** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata -** associated by the sqlite3_set_auxdata() function with the Nth argument -** value to the application-defined function. ^If no metadata has been ever -** been set for the Nth argument of the function, or if the corresponding -** function parameter has changed since the meta-data was set, -** then sqlite3_get_auxdata() returns a NULL pointer. -** -** ^The sqlite3_set_auxdata() interface saves the metadata -** pointed to by its 3rd parameter as the metadata for the N-th -** argument of the application-defined function. Subsequent -** calls to sqlite3_get_auxdata() might return this data, if it has -** not been destroyed. -** ^If it is not NULL, SQLite will invoke the destructor -** function given by the 4th parameter to sqlite3_set_auxdata() on -** the metadata when the corresponding function parameter changes -** or when the SQL statement completes, whichever comes first. -** -** SQLite is free to call the destructor and drop metadata on any -** parameter of any function at any time. ^The only guarantee is that -** the destructor will be called before the metadata is dropped. -** -** ^(In practice, metadata is preserved between function calls for -** expressions that are constant at compile time. This includes literal -** values and [parameters].)^ -** -** These routines must be called from the same thread in which -** the SQL function is running. -*/ -SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); -SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); - - -/* -** CAPI3REF: Constants Defining Special Destructor Behavior -** -** These are special values for the destructor that is passed in as the -** final argument to routines like [sqlite3_result_blob()]. ^If the destructor -** argument is SQLITE_STATIC, it means that the content pointer is constant -** and will never change. It does not need to be destroyed. ^The -** SQLITE_TRANSIENT value means that the content will likely change in -** the near future and that SQLite should make its own private copy of -** the content before returning. -** -** The typedef is necessary to work around problems in certain -** C++ compilers. See ticket #2191. -*/ -typedef void (*sqlite3_destructor_type)(void*); -#define SQLITE_STATIC ((sqlite3_destructor_type)0) -#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) - -/* -** CAPI3REF: Setting The Result Of An SQL Function -** -** These routines are used by the xFunc or xFinal callbacks that -** implement SQL functions and aggregates. See -** [sqlite3_create_function()] and [sqlite3_create_function16()] -** for additional information. -** -** These functions work very much like the [parameter binding] family of -** functions used to bind values to host parameters in prepared statements. -** Refer to the [SQL parameter] documentation for additional information. -** -** ^The sqlite3_result_blob() interface sets the result from -** an application-defined function to be the BLOB whose content is pointed -** to by the second parameter and which is N bytes long where N is the -** third parameter. -** -** ^The sqlite3_result_zeroblob() interfaces set the result of -** the application-defined function to be a BLOB containing all zero -** bytes and N bytes in size, where N is the value of the 2nd parameter. -** -** ^The sqlite3_result_double() interface sets the result from -** an application-defined function to be a floating point value specified -** by its 2nd argument. -** -** ^The sqlite3_result_error() and sqlite3_result_error16() functions -** cause the implemented SQL function to throw an exception. -** ^SQLite uses the string pointed to by the -** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() -** as the text of an error message. ^SQLite interprets the error -** message string from sqlite3_result_error() as UTF-8. ^SQLite -** interprets the string from sqlite3_result_error16() as UTF-16 in native -** byte order. ^If the third parameter to sqlite3_result_error() -** or sqlite3_result_error16() is negative then SQLite takes as the error -** message all text up through the first zero character. -** ^If the third parameter to sqlite3_result_error() or -** sqlite3_result_error16() is non-negative then SQLite takes that many -** bytes (not characters) from the 2nd parameter as the error message. -** ^The sqlite3_result_error() and sqlite3_result_error16() -** routines make a private copy of the error message text before -** they return. Hence, the calling function can deallocate or -** modify the text after they return without harm. -** ^The sqlite3_result_error_code() function changes the error code -** returned by SQLite as a result of an error in a function. ^By default, -** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() -** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. -** -** ^The sqlite3_result_toobig() interface causes SQLite to throw an error -** indicating that a string or BLOB is too long to represent. -** -** ^The sqlite3_result_nomem() interface causes SQLite to throw an error -** indicating that a memory allocation failed. -** -** ^The sqlite3_result_int() interface sets the return value -** of the application-defined function to be the 32-bit signed integer -** value given in the 2nd argument. -** ^The sqlite3_result_int64() interface sets the return value -** of the application-defined function to be the 64-bit signed integer -** value given in the 2nd argument. -** -** ^The sqlite3_result_null() interface sets the return value -** of the application-defined function to be NULL. -** -** ^The sqlite3_result_text(), sqlite3_result_text16(), -** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces -** set the return value of the application-defined function to be -** a text string which is represented as UTF-8, UTF-16 native byte order, -** UTF-16 little endian, or UTF-16 big endian, respectively. -** ^SQLite takes the text result from the application from -** the 2nd parameter of the sqlite3_result_text* interfaces. -** ^If the 3rd parameter to the sqlite3_result_text* interfaces -** is negative, then SQLite takes result text from the 2nd parameter -** through the first zero character. -** ^If the 3rd parameter to the sqlite3_result_text* interfaces -** is non-negative, then as many bytes (not characters) of the text -** pointed to by the 2nd parameter are taken as the application-defined -** function result. -** ^If the 4th parameter to the sqlite3_result_text* interfaces -** 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 -** finished using that result. -** ^If the 4th parameter to the sqlite3_result_text* interfaces or to -** 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 -** 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 -** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT -** then SQLite makes a copy of the result into space obtained from -** from [sqlite3_malloc()] before it returns. -** -** ^The sqlite3_result_value() interface sets the result of -** the application-defined function to be a copy the -** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The -** sqlite3_result_value() interface makes a copy of the [sqlite3_value] -** so that the [sqlite3_value] specified in the parameter may change or -** be deallocated after sqlite3_result_value() returns without harm. -** ^A [protected sqlite3_value] object may always be used where an -** [unprotected sqlite3_value] object is required, so either -** kind of [sqlite3_value] object can be used with this interface. -** -** If these routines are called from within the different thread -** than the one containing the application-defined function that received -** the [sqlite3_context] pointer, the results are undefined. -*/ -SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_double(sqlite3_context*, double); -SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); -SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); -SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); -SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); -SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); -SQLITE_API void sqlite3_result_int(sqlite3_context*, int); -SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); -SQLITE_API void sqlite3_result_null(sqlite3_context*); -SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); -SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); -SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); -SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); -SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); - -/* -** CAPI3REF: Define New Collating Sequences -** -** These functions are used to add new collation sequences to the -** [database connection] specified as the first argument. -** -** ^The name of the new collation sequence is specified as a UTF-8 string -** for sqlite3_create_collation() and sqlite3_create_collation_v2() -** and a UTF-16 string for sqlite3_create_collation16(). ^In all cases -** the name is passed as the second function argument. -** -** ^The third argument may be one of the constants [SQLITE_UTF8], -** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied -** routine expects to be passed pointers to strings encoded using UTF-8, -** UTF-16 little-endian, or UTF-16 big-endian, respectively. ^The -** third argument might also be [SQLITE_UTF16] to indicate that the routine -** expects pointers to be UTF-16 strings in the native byte order, or the -** argument can be [SQLITE_UTF16_ALIGNED] if the -** the routine expects pointers to 16-bit word aligned strings -** of UTF-16 in the native byte order. -** -** A pointer to the user supplied routine must be passed as the fifth -** argument. ^If it is NULL, this is the same as deleting the collation -** sequence (so that SQLite cannot call it anymore). -** ^Each time the application supplied function is invoked, it is passed -** as its first parameter a copy of the void* passed as the fourth argument -** to sqlite3_create_collation() or sqlite3_create_collation16(). -** -** ^The remaining arguments to the application-supplied routine are two strings, -** each represented by a (length, data) pair and encoded in the encoding -** that was passed as the third argument when the collation sequence was -** registered. The application defined collation routine should -** return negative, zero or positive if the first string is less than, -** equal to, or greater than the second string. i.e. (STRING1 - STRING2). -** -** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() -** except that it takes an extra argument which is a destructor for -** the collation. ^The destructor is called when the collation is -** destroyed and is passed a copy of the fourth parameter void* pointer -** of the sqlite3_create_collation_v2(). -** ^Collations are destroyed when they are overridden by later calls to the -** collation creation functions or when the [database connection] is closed -** using [sqlite3_close()]. -** -** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. -*/ -SQLITE_API int sqlite3_create_collation( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); -SQLITE_API int sqlite3_create_collation_v2( - sqlite3*, - const char *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*), - void(*xDestroy)(void*) -); -SQLITE_API int sqlite3_create_collation16( - sqlite3*, - const void *zName, - int eTextRep, - void*, - int(*xCompare)(void*,int,const void*,int,const void*) -); - -/* -** CAPI3REF: Collation Needed Callbacks -** -** ^To avoid having to register all collation sequences before a database -** can be used, a single callback function may be registered with the -** [database connection] to be invoked whenever an undefined collation -** sequence is required. -** -** ^If the function is registered using the sqlite3_collation_needed() API, -** then it is passed the names of undefined collation sequences as strings -** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, -** the names are passed as UTF-16 in machine native byte order. -** ^A call to either function replaces the existing collation-needed callback. -** -** ^(When the callback is invoked, the first argument passed is a copy -** of the second argument to sqlite3_collation_needed() or -** sqlite3_collation_needed16(). The second argument is the database -** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], -** or [SQLITE_UTF16LE], indicating the most desirable form of the collation -** sequence function required. The fourth parameter is the name of the -** required collation sequence.)^ -** -** The callback function should register the desired collation using -** [sqlite3_create_collation()], [sqlite3_create_collation16()], or -** [sqlite3_create_collation_v2()]. -*/ -SQLITE_API int sqlite3_collation_needed( - sqlite3*, - void*, - void(*)(void*,sqlite3*,int eTextRep,const char*) -); -SQLITE_API int sqlite3_collation_needed16( - sqlite3*, - void*, - void(*)(void*,sqlite3*,int eTextRep,const void*) -); - -#if SQLITE_HAS_CODEC -/* -** Specify the key for an encrypted database. This routine should be -** called right after sqlite3_open(). -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_key( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The key */ -); - -/* -** Change the key on an open database. If the current database is not -** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the -** database is decrypted. -** -** The code to implement this API is not available in the public release -** of SQLite. -*/ -SQLITE_API int sqlite3_rekey( - sqlite3 *db, /* Database to be rekeyed */ - const void *pKey, int nKey /* The new key */ -); - -/* -** Specify the activation key for a SEE database. Unless -** activated, none of the SEE routines will work. -*/ -SQLITE_API void sqlite3_activate_see( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -#ifdef SQLITE_ENABLE_CEROD -/* -** Specify the activation key for a CEROD database. Unless -** activated, none of the CEROD routines will work. -*/ -SQLITE_API void sqlite3_activate_cerod( - const char *zPassPhrase /* Activation phrase */ -); -#endif - -/* -** CAPI3REF: Suspend Execution For A Short Time -** -** ^The sqlite3_sleep() function causes the current thread to suspend execution -** for at least a number of milliseconds specified in its parameter. -** -** ^If the operating system does not support sleep requests with -** millisecond time resolution, then the time will be rounded up to -** the nearest second. ^The number of milliseconds of sleep actually -** requested from the operating system is returned. -** -** ^SQLite implements this interface by calling the xSleep() -** method of the default [sqlite3_vfs] object. -*/ -SQLITE_API int sqlite3_sleep(int); - -/* -** CAPI3REF: Name Of The Folder Holding Temporary Files -** -** ^(If this global variable is made to point to a string which is -** the name of a folder (a.k.a. directory), then all temporary files -** created by SQLite when using a built-in [sqlite3_vfs | VFS] -** will be placed in that directory.)^ ^If this variable -** is a NULL pointer, then SQLite performs a search for an appropriate -** temporary file directory. -** -** It is not safe to read or modify this variable in more than one -** thread at a time. It is not safe to read or modify this variable -** if a [database connection] is being used at the same time in a separate -** thread. -** It is intended that this variable be set once -** as part of process initialization and before any SQLite interface -** routines have been called and that this variable remain unchanged -** thereafter. -** -** ^The [temp_store_directory pragma] may modify this variable and cause -** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, -** the [temp_store_directory pragma] always assumes that any string -** that this variable points to is held in memory obtained from -** [sqlite3_malloc] and the pragma may attempt to free that memory -** using [sqlite3_free]. -** Hence, if this variable is modified directly, either it should be -** made NULL or made to point to memory obtained from [sqlite3_malloc] -** or else the use of the [temp_store_directory pragma] should be avoided. -*/ -SQLITE_API char *sqlite3_temp_directory; - -/* -** CAPI3REF: Test For Auto-Commit Mode -** KEYWORDS: {autocommit mode} -** -** ^The sqlite3_get_autocommit() interface returns non-zero or -** zero if the given database connection is or is not in autocommit mode, -** respectively. ^Autocommit mode is on by default. -** ^Autocommit mode is disabled by a [BEGIN] statement. -** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. -** -** If certain kinds of errors occur on a statement within a multi-statement -** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], -** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the -** transaction might be rolled back automatically. The only way to -** find out whether SQLite automatically rolled back the transaction after -** an error is to use this function. -** -** If another thread changes the autocommit status of the database -** connection while this routine is running, then the return value -** is undefined. -*/ -SQLITE_API int sqlite3_get_autocommit(sqlite3*); - -/* -** CAPI3REF: Find The Database Handle Of A Prepared Statement -** -** ^The sqlite3_db_handle interface returns the [database connection] handle -** to which a [prepared statement] belongs. ^The [database connection] -** returned by sqlite3_db_handle is the same [database connection] -** that was the first argument -** to the [sqlite3_prepare_v2()] call (or its variants) that was used to -** create the statement in the first place. -*/ -SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); - -/* -** CAPI3REF: Find the next prepared statement -** -** ^This interface returns a pointer to the next [prepared statement] after -** pStmt associated with the [database connection] pDb. ^If pStmt is NULL -** then this interface returns a pointer to the first prepared statement -** associated with the database connection pDb. ^If no prepared statement -** satisfies the conditions of this routine, it returns NULL. -** -** The [database connection] pointer D in a call to -** [sqlite3_next_stmt(D,S)] must refer to an open database -** connection and in particular must not be a NULL pointer. -*/ -SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); - -/* -** CAPI3REF: Commit And Rollback Notification Callbacks -** -** ^The sqlite3_commit_hook() interface registers a callback -** function to be invoked whenever a transaction is [COMMIT | committed]. -** ^Any callback set by a previous call to sqlite3_commit_hook() -** for the same database connection is overridden. -** ^The sqlite3_rollback_hook() interface registers a callback -** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. -** ^Any callback set by a previous call to sqlite3_rollback_hook() -** for the same database connection is overridden. -** ^The pArg argument is passed through to the callback. -** ^If the callback on a commit hook function returns non-zero, -** then the commit is converted into a rollback. -** -** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions -** return the P argument from the previous call of the same function -** on the same [database connection] D, or NULL for -** the first call for each function on D. -** -** The callback implementation must not do anything that will modify -** the database connection that invoked the callback. Any actions -** to modify the database connection must be deferred until after the -** completion of the [sqlite3_step()] call that triggered the commit -** or rollback hook in the first place. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^Registering a NULL function disables the callback. -** -** ^When the commit hook callback routine returns zero, the [COMMIT] -** operation is allowed to continue normally. ^If the commit hook -** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. -** ^The rollback hook is invoked on a rollback that results from a commit -** hook returning non-zero, just as it would be with any other rollback. -** -** ^For the purposes of this API, a transaction is said to have been -** rolled back if an explicit "ROLLBACK" statement is executed, or -** an error or constraint causes an implicit rollback to occur. -** ^The rollback callback is not invoked if a transaction is -** automatically rolled back because the database connection is closed. -** ^The rollback callback is not invoked if a transaction is -** rolled back because a commit callback returned non-zero. -** -** See also the [sqlite3_update_hook()] interface. -*/ -SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); -SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); - -/* -** CAPI3REF: Data Change Notification Callbacks -** -** ^The sqlite3_update_hook() interface registers a callback function -** with the [database connection] identified by the first argument -** to be invoked whenever a row is updated, inserted or deleted. -** ^Any callback set by a previous call to this function -** for the same database connection is overridden. -** -** ^The second argument is a pointer to the function to invoke when a -** row is updated, inserted or deleted. -** ^The first argument to the callback is a copy of the third argument -** to sqlite3_update_hook(). -** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], -** or [SQLITE_UPDATE], depending on the operation that caused the callback -** to be invoked. -** ^The third and fourth arguments to the callback contain pointers to the -** database and table name containing the affected row. -** ^The final callback parameter is the [rowid] of the row. -** ^In the case of an update, this is the [rowid] after the update takes place. -** -** ^(The update hook is not invoked when internal system tables are -** modified (i.e. sqlite_master and sqlite_sequence).)^ -** -** ^In the current implementation, the update hook -** is not invoked when duplication rows are deleted because of an -** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook -** invoked when rows are deleted using the [truncate optimization]. -** The exceptions defined in this paragraph might change in a future -** release of SQLite. -** -** The update hook implementation must not do anything that will modify -** the database connection that invoked the update hook. Any actions -** to modify the database connection must be deferred until after the -** completion of the [sqlite3_step()] call that triggered the update hook. -** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their -** database connections for the meaning of "modify" in this paragraph. -** -** ^The sqlite3_update_hook(D,C,P) function -** returns the P argument from the previous call -** on the same [database connection] D, or NULL for -** the first call on D. -** -** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()] -** interfaces. -*/ -SQLITE_API void *sqlite3_update_hook( - sqlite3*, - void(*)(void *,int ,char const *,char const *,sqlite3_int64), - void* -); - -/* -** CAPI3REF: Enable Or Disable Shared Pager Cache -** KEYWORDS: {shared cache} -** -** ^(This routine enables or disables the sharing of the database cache -** and schema data structures between [database connection | connections] -** to the same database. Sharing is enabled if the argument is true -** and disabled if the argument is false.)^ -** -** ^Cache sharing is enabled and disabled for an entire process. -** This is a change as of SQLite version 3.5.0. In prior versions of SQLite, -** sharing was enabled or disabled for each thread separately. -** -** ^(The cache sharing mode set by this interface effects all subsequent -** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. -** Existing database connections continue use the sharing mode -** that was in effect at the time they were opened.)^ -** -** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled -** successfully. An [error code] is returned otherwise.)^ -** -** ^Shared cache is disabled by default. But this might change in -** future releases of SQLite. Applications that care about shared -** cache setting should set it explicitly. -** -** See Also: [SQLite Shared-Cache Mode] -*/ -SQLITE_API int sqlite3_enable_shared_cache(int); - -/* -** CAPI3REF: Attempt To Free Heap Memory -** -** ^The sqlite3_release_memory() interface attempts to free N bytes -** of heap memory by deallocating non-essential memory allocations -** held by the database library. Memory used to cache database -** pages to improve performance is an example of non-essential memory. -** ^sqlite3_release_memory() returns the number of bytes actually freed, -** which might be more or less than the amount requested. -*/ -SQLITE_API int sqlite3_release_memory(int); - -/* -** CAPI3REF: Impose A Limit On Heap Size -** -** ^The sqlite3_soft_heap_limit() interface places a "soft" limit -** on the amount of heap memory that may be allocated by SQLite. -** ^If an internal allocation is requested that would exceed the -** soft heap limit, [sqlite3_release_memory()] is invoked one or -** more times to free up some space before the allocation is performed. -** -** ^The limit is called "soft" because if [sqlite3_release_memory()] -** cannot free sufficient memory to prevent the limit from being exceeded, -** the memory is allocated anyway and the current operation proceeds. -** -** ^A negative or zero value for N means that there is no soft heap limit and -** [sqlite3_release_memory()] will only be called when memory is exhausted. -** ^The default value for the soft heap limit is zero. -** -** ^(SQLite makes a best effort to honor the soft heap limit. -** But if the soft heap limit cannot be honored, execution will -** continue without error or notification.)^ This is why the limit is -** called a "soft" limit. It is advisory only. -** -** Prior to SQLite version 3.5.0, this routine only constrained the memory -** allocated by a single thread - the same thread in which this routine -** runs. Beginning with SQLite version 3.5.0, the soft heap limit is -** applied to all threads. The value specified for the soft heap limit -** is an upper bound on the total memory allocation for all threads. In -** version 3.5.0 there is no mechanism for limiting the heap usage for -** individual threads. -*/ -SQLITE_API void sqlite3_soft_heap_limit(int); - -/* -** CAPI3REF: Extract Metadata About A Column Of A Table -** -** ^This routine returns metadata about a specific column of a specific -** database table accessible using the [database connection] handle -** passed as the first function argument. -** -** ^The column is identified by the second, third and fourth parameters to -** this function. ^The second parameter is either the name of the database -** (i.e. "main", "temp", or an attached database) containing the specified -** table or NULL. ^If it is NULL, then all attached databases are searched -** for the table using the same algorithm used by the database engine to -** resolve unqualified table references. -** -** ^The third and fourth parameters to this function are the table and column -** name of the desired column, respectively. Neither of these parameters -** may be NULL. -** -** ^Metadata is returned by writing to the memory locations passed as the 5th -** and subsequent parameters to this function. ^Any of these arguments may be -** NULL, in which case the corresponding element of metadata is omitted. -** -** ^(
-** -**
Parameter Output
Type 		Description -** -**
5th const char* Data type -**
6th const char* Name of default collation sequence -**
7th int True if column has a NOT NULL constraint -**
8th int True if column is part of the PRIMARY KEY -**
9th int True if column is [AUTOINCREMENT] -**
-**
)^ -** -** ^The memory pointed to by the character pointers returned for the -** declaration type and collation sequence is valid only until the next -** call to any SQLite API function. -** -** ^If the specified table is actually a view, an [error code] is returned. -** -** ^If the specified column is "rowid", "oid" or "_rowid_" and an -** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output -** parameters are set for the explicitly declared column. ^(If there is no -** explicitly declared [INTEGER PRIMARY KEY] column, then the output -** parameters are set as follows: -** -** 
-**     data type: "INTEGER"
-**     collation sequence: "BINARY"
-**     not null: 0
-**     primary key: 1
-**     auto increment: 0
-**
)^ -** -** ^(This function may load one or more schemas from database files. If an -** error occurs during this process, or if the requested table or column -** cannot be found, an [error code] is returned and an error message left -** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ -** -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. -*/ -SQLITE_API int sqlite3_table_column_metadata( - sqlite3 *db, /* Connection handle */ - const char *zDbName, /* Database name or NULL */ - const char *zTableName, /* Table name */ - const char *zColumnName, /* Column name */ - char const **pzDataType, /* OUTPUT: Declared data type */ - char const **pzCollSeq, /* OUTPUT: Collation sequence name */ - int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ - int *pPrimaryKey, /* OUTPUT: True if column part of PK */ - int *pAutoinc /* OUTPUT: True if column is auto-increment */ -); - -/* -** CAPI3REF: Load An Extension -** -** ^This interface loads an SQLite extension library from the named file. -** -** ^The sqlite3_load_extension() interface attempts to load an -** SQLite extension library contained in the file zFile. -** -** ^The entry point is zProc. -** ^zProc may be 0, in which case the name of the entry point -** defaults to "sqlite3_extension_init". -** ^The sqlite3_load_extension() interface returns -** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. -** ^If an error occurs and pzErrMsg is not 0, then the -** [sqlite3_load_extension()] interface shall attempt to -** fill *pzErrMsg with error message text stored in memory -** obtained from [sqlite3_malloc()]. The calling function -** should free this memory by calling [sqlite3_free()]. -** -** ^Extension loading must be enabled using -** [sqlite3_enable_load_extension()] prior to calling this API, -** otherwise an error will be returned. -** -** See also the [load_extension() SQL function]. -*/ -SQLITE_API int sqlite3_load_extension( - sqlite3 *db, /* Load the extension into this database connection */ - const char *zFile, /* Name of the shared library containing extension */ - const char *zProc, /* Entry point. Derived from zFile if 0 */ - char **pzErrMsg /* Put error message here if not 0 */ -); - -/* -** CAPI3REF: Enable Or Disable Extension Loading -** -** ^So as not to open security holes in older applications that are -** unprepared to deal with extension loading, and as a means of disabling -** extension loading while evaluating user-entered SQL, the following API -** is provided to turn the [sqlite3_load_extension()] mechanism on and off. -** -** ^Extension loading is off by default. See ticket #1863. -** ^Call the sqlite3_enable_load_extension() routine with onoff==1 -** to turn extension loading on and call it with onoff==0 to turn -** it back off again. -*/ -SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); - -/* -** CAPI3REF: Automatically Load An Extensions -** -** ^This API can be invoked at program startup in order to register -** one or more statically linked extensions that will be available -** to all new [database connections]. -** -** ^(This routine stores a pointer to the extension entry point -** in an array that is obtained from [sqlite3_malloc()]. That memory -** is deallocated by [sqlite3_reset_auto_extension()].)^ -** -** ^This function registers an extension entry point that is -** automatically invoked whenever a new [database connection] -** is opened using [sqlite3_open()], [sqlite3_open16()], -** or [sqlite3_open_v2()]. -** ^Duplicate extensions are detected so calling this routine -** multiple times with the same extension is harmless. -** ^Automatic extensions apply across all threads. -*/ -SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); - -/* -** CAPI3REF: Reset Automatic Extension Loading -** -** ^(This function disables all previously registered automatic -** extensions. It undoes the effect of all prior -** [sqlite3_auto_extension()] calls.)^ -** -** ^This function disables automatic extensions in all threads. -*/ -SQLITE_API void sqlite3_reset_auto_extension(void); - -/* -****** EXPERIMENTAL - subject to change without notice ************** -** -** The interface to the virtual-table mechanism is currently considered -** to be experimental. The interface might change in incompatible ways. -** If this is a problem for you, do not use the interface at this time. -** -** When the virtual-table mechanism stabilizes, we will declare the -** interface fixed, support it indefinitely, and remove this comment. -*/ - -/* -** Structures used by the virtual table interface -*/ -typedef struct sqlite3_vtab sqlite3_vtab; -typedef struct sqlite3_index_info sqlite3_index_info; -typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; -typedef struct sqlite3_module sqlite3_module; - -/* -** CAPI3REF: Virtual Table Object -** KEYWORDS: sqlite3_module {virtual table module} -** EXPERIMENTAL -** -** This structure, sometimes called a a "virtual table module", -** defines the implementation of a [virtual tables]. -** This structure consists mostly of methods for the module. -** -** ^A virtual table module is created by filling in a persistent -** instance of this structure and passing a pointer to that instance -** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. -** ^The registration remains valid until it is replaced by a different -** module or until the [database connection] closes. The content -** of this structure must not change while it is registered with -** any database connection. -*/ -struct sqlite3_module { - int iVersion; - int (*xCreate)(sqlite3*, void *pAux, - int argc, const char *const*argv, - sqlite3_vtab **ppVTab, char**); - int (*xConnect)(sqlite3*, void *pAux, - int argc, const char *const*argv, - sqlite3_vtab **ppVTab, char**); - int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); - int (*xDisconnect)(sqlite3_vtab *pVTab); - int (*xDestroy)(sqlite3_vtab *pVTab); - int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); - int (*xClose)(sqlite3_vtab_cursor*); - int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, - int argc, sqlite3_value **argv); - int (*xNext)(sqlite3_vtab_cursor*); - int (*xEof)(sqlite3_vtab_cursor*); - int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); - int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); - int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); - int (*xBegin)(sqlite3_vtab *pVTab); - int (*xSync)(sqlite3_vtab *pVTab); - int (*xCommit)(sqlite3_vtab *pVTab); - int (*xRollback)(sqlite3_vtab *pVTab); - int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, - void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), - void **ppArg); - int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); -}; - -/* -** CAPI3REF: Virtual Table Indexing Information -** KEYWORDS: sqlite3_index_info -** EXPERIMENTAL -** -** The sqlite3_index_info structure and its substructures is used to -** pass information into and receive the reply from the [xBestIndex] -** method of a [virtual table module]. The fields under **Inputs** are the -** inputs to xBestIndex and are read-only. xBestIndex inserts its -** results into the **Outputs** fields. -** -** ^(The aConstraint[] array records WHERE clause constraints of the form: -** -** 
column OP expr
-** -** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is -** stored in aConstraint[].op.)^ ^(The index of the column is stored in -** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the -** expr on the right-hand side can be evaluated (and thus the constraint -** is usable) and false if it cannot.)^ -** -** ^The optimizer automatically inverts terms of the form "expr OP column" -** and makes other simplifications to the WHERE clause in an attempt to -** get as many WHERE clause terms into the form shown above as possible. -** ^The aConstraint[] array only reports WHERE clause terms that are -** relevant to the particular virtual table being queried. -** -** ^Information about the ORDER BY clause is stored in aOrderBy[]. -** ^Each term of aOrderBy records a column of the ORDER BY clause. -** -** The [xBestIndex] method must fill aConstraintUsage[] with information -** about what parameters to pass to xFilter. ^If argvIndex>0 then -** the right-hand side of the corresponding aConstraint[] is evaluated -** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit -** is true, then the constraint is assumed to be fully handled by the -** virtual table and is not checked again by SQLite.)^ -** -** ^The idxNum and idxPtr values are recorded and passed into the -** [xFilter] method. -** ^[sqlite3_free()] is used to free idxPtr if and only if -** needToFreeIdxPtr is true. -** -** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in -** the correct order to satisfy the ORDER BY clause so that no separate -** sorting step is required. -** -** ^The estimatedCost value is an estimate of the cost of doing the -** particular lookup. A full scan of a table with N entries should have -** a cost of N. A binary search of a table of N entries should have a -** cost of approximately log(N). -*/ -struct sqlite3_index_info { - /* Inputs */ - int nConstraint; /* Number of entries in aConstraint */ - struct sqlite3_index_constraint { - int iColumn; /* Column on left-hand side of constraint */ - unsigned char op; /* Constraint operator */ - unsigned char usable; /* True if this constraint is usable */ - int iTermOffset; /* Used internally - xBestIndex should ignore */ - } *aConstraint; /* Table of WHERE clause constraints */ - int nOrderBy; /* Number of terms in the ORDER BY clause */ - struct sqlite3_index_orderby { - int iColumn; /* Column number */ - unsigned char desc; /* True for DESC. False for ASC. */ - } *aOrderBy; /* The ORDER BY clause */ - /* Outputs */ - struct sqlite3_index_constraint_usage { - int argvIndex; /* if >0, constraint is part of argv to xFilter */ - unsigned char omit; /* Do not code a test for this constraint */ - } *aConstraintUsage; - int idxNum; /* Number used to identify the index */ - char *idxStr; /* String, possibly obtained from sqlite3_malloc */ - int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ - int orderByConsumed; /* True if output is already ordered */ - double estimatedCost; /* Estimated cost of using this index */ -}; -#define SQLITE_INDEX_CONSTRAINT_EQ 2 -#define SQLITE_INDEX_CONSTRAINT_GT 4 -#define SQLITE_INDEX_CONSTRAINT_LE 8 -#define SQLITE_INDEX_CONSTRAINT_LT 16 -#define SQLITE_INDEX_CONSTRAINT_GE 32 -#define SQLITE_INDEX_CONSTRAINT_MATCH 64 - -/* -** CAPI3REF: Register A Virtual Table Implementation -** EXPERIMENTAL -** -** ^These routines are used to register a new [virtual table module] name. -** ^Module names must be registered before -** creating a new [virtual table] using the module and before using a -** preexisting [virtual table] for the module. -** -** ^The module name is registered on the [database connection] specified -** by the first parameter. ^The name of the module is given by the -** second parameter. ^The third parameter is a pointer to -** the implementation of the [virtual table module]. ^The fourth -** parameter is an arbitrary client data pointer that is passed through -** into the [xCreate] and [xConnect] methods of the virtual table module -** when a new virtual table is be being created or reinitialized. -** -** ^The sqlite3_create_module_v2() interface has a fifth parameter which -** is a pointer to a destructor for the pClientData. ^SQLite will -** invoke the destructor function (if it is not NULL) when SQLite -** no longer needs the pClientData pointer. ^The sqlite3_create_module() -** interface is equivalent to sqlite3_create_module_v2() with a NULL -** destructor. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module( - sqlite3 *db, /* SQLite connection to register module with */ - const char *zName, /* Name of the module */ - const sqlite3_module *p, /* Methods for the module */ - void *pClientData /* Client data for xCreate/xConnect */ -); -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module_v2( - sqlite3 *db, /* SQLite connection to register module with */ - const char *zName, /* Name of the module */ - const sqlite3_module *p, /* Methods for the module */ - void *pClientData, /* Client data for xCreate/xConnect */ - void(*xDestroy)(void*) /* Module destructor function */ -); - -/* -** CAPI3REF: Virtual Table Instance Object -** KEYWORDS: sqlite3_vtab -** EXPERIMENTAL -** -** Every [virtual table module] implementation uses a subclass -** of this object to describe a particular instance -** of the [virtual table]. Each subclass will -** be tailored to the specific needs of the module implementation. -** The purpose of this superclass is to define certain fields that are -** common to all module implementations. -** -** ^Virtual tables methods can set an error message by assigning a -** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should -** take care that any prior string is freed by a call to [sqlite3_free()] -** prior to assigning a new string to zErrMsg. ^After the error message -** is delivered up to the client application, the string will be automatically -** freed by sqlite3_free() and the zErrMsg field will be zeroed. -*/ -struct sqlite3_vtab { - const sqlite3_module *pModule; /* The module for this virtual table */ - int nRef; /* NO LONGER USED */ - char *zErrMsg; /* Error message from sqlite3_mprintf() */ - /* Virtual table implementations will typically add additional fields */ -}; - -/* -** CAPI3REF: Virtual Table Cursor Object -** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} -** EXPERIMENTAL -** -** Every [virtual table module] implementation uses a subclass of the -** following structure to describe cursors that point into the -** [virtual table] and are used -** to loop through the virtual table. Cursors are created using the -** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed -** by the [sqlite3_module.xClose | xClose] method. Cursors are used -** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods -** of the module. Each module implementation will define -** the content of a cursor structure to suit its own needs. -** -** This superclass exists in order to define fields of the cursor that -** are common to all implementations. -*/ -struct sqlite3_vtab_cursor { - sqlite3_vtab *pVtab; /* Virtual table of this cursor */ - /* Virtual table implementations will typically add additional fields */ -}; - -/* -** CAPI3REF: Declare The Schema Of A Virtual Table -** EXPERIMENTAL -** -** ^The [xCreate] and [xConnect] methods of a -** [virtual table module] call this interface -** to declare the format (the names and datatypes of the columns) of -** the virtual tables they implement. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL); - -/* -** CAPI3REF: Overload A Function For A Virtual Table -** EXPERIMENTAL -** -** ^(Virtual tables can provide alternative implementations of functions -** using the [xFindFunction] method of the [virtual table module]. -** But global versions of those functions -** must exist in order to be overloaded.)^ -** -** ^(This API makes sure a global version of a function with a particular -** name and number of parameters exists. If no such function exists -** before this API is called, a new function is created.)^ ^The implementation -** of the new function always causes an exception to be thrown. So -** the new function is not good for anything by itself. Its only -** purpose is to be a placeholder function that can be overloaded -** by a [virtual table]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); - -/* -** The interface to the virtual-table mechanism defined above (back up -** to a comment remarkably similar to this one) is currently considered -** to be experimental. The interface might change in incompatible ways. -** If this is a problem for you, do not use the interface at this time. -** -** When the virtual-table mechanism stabilizes, we will declare the -** interface fixed, support it indefinitely, and remove this comment. -** -****** EXPERIMENTAL - subject to change without notice ************** -*/ - -/* -** CAPI3REF: A Handle To An Open BLOB -** KEYWORDS: {BLOB handle} {BLOB handles} -** -** An instance of this object represents an open BLOB on which -** [sqlite3_blob_open | incremental BLOB I/O] can be performed. -** ^Objects of this type are created by [sqlite3_blob_open()] -** and destroyed by [sqlite3_blob_close()]. -** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces -** can be used to read or write small subsections of the BLOB. -** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. -*/ -typedef struct sqlite3_blob sqlite3_blob; - -/* -** CAPI3REF: Open A BLOB For Incremental I/O -** -** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located -** in row iRow, column zColumn, table zTable in database zDb; -** in other words, the same BLOB that would be selected by: -** -** 
-**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
-**
)^ -** -** ^If the flags parameter is non-zero, then the BLOB is opened for read -** and write access. ^If it is zero, the BLOB is opened for read access. -** ^It is not possible to open a column that is part of an index or primary -** key for writing. ^If [foreign key constraints] are enabled, it is -** not possible to open a column that is part of a [child key] for writing. -** -** ^Note that the database name is not the filename that contains -** the database but rather the symbolic name of the database that -** appears after the AS keyword when the database is connected using [ATTACH]. -** ^For the main database file, the database name is "main". -** ^For TEMP tables, the database name is "temp". -** -** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written -** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set -** to be a null pointer.)^ -** ^This function sets the [database connection] error code and message -** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related -** functions. ^Note that the *ppBlob variable is always initialized in a -** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob -** regardless of the success or failure of this routine. -** -** ^(If the row that a BLOB handle points to is modified by an -** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects -** then the BLOB handle is marked as "expired". -** This is true if any column of the row is changed, even a column -** other than the one the BLOB handle is open on.)^ -** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for -** a expired BLOB handle fail with an return code of [SQLITE_ABORT]. -** ^(Changes written into a BLOB prior to the BLOB expiring are not -** rolled back by the expiration of the BLOB. Such changes will eventually -** commit if the transaction continues to completion.)^ -** -** ^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 -** interface. Use the [UPDATE] SQL command to change the size of a -** blob. -** -** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces -** and the built-in [zeroblob] SQL function can be used, if desired, -** to create an empty, zero-filled blob in which to read or write using -** this interface. -** -** To avoid a resource leak, every open [BLOB handle] should eventually -** be released by a call to [sqlite3_blob_close()]. -*/ -SQLITE_API int sqlite3_blob_open( - sqlite3*, - const char *zDb, - const char *zTable, - const char *zColumn, - sqlite3_int64 iRow, - int flags, - sqlite3_blob **ppBlob -); - -/* -** CAPI3REF: Close A BLOB Handle -** -** ^Closes an open [BLOB handle]. -** -** ^Closing a BLOB shall cause the current transaction to commit -** if there are no other BLOBs, no pending prepared statements, and the -** database connection is in [autocommit mode]. -** ^If any writes were made to the BLOB, they might be held in cache -** until the close operation if they will fit. -** -** ^(Closing the BLOB often forces the changes -** out to disk and so if any I/O errors occur, they will likely occur -** at the time when the BLOB is closed. Any errors that occur during -** closing are reported as a non-zero return value.)^ -** -** ^(The BLOB is closed unconditionally. Even if this routine returns -** an error code, the BLOB is still closed.)^ -** -** ^Calling this routine with a null pointer (such as would be returned -** by a failed call to [sqlite3_blob_open()]) is a harmless no-op. -*/ -SQLITE_API int sqlite3_blob_close(sqlite3_blob *); - -/* -** CAPI3REF: Return The Size Of An Open BLOB -** -** ^Returns the size in bytes of the BLOB accessible via the -** successfully opened [BLOB handle] in its only argument. ^The -** incremental blob I/O routines can only read or overwriting existing -** blob content; they cannot change the size of a blob. -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -*/ -SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); - -/* -** CAPI3REF: Read Data From A BLOB Incrementally -** -** ^(This function is used to read data from an open [BLOB handle] into a -** caller-supplied buffer. N bytes of data are copied into buffer Z -** from the open BLOB, starting at offset iOffset.)^ -** -** ^If offset iOffset is less than N bytes from the end of the BLOB, -** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is -** less than zero, [SQLITE_ERROR] is returned and no data is read. -** ^The size of the blob (and hence the maximum value of N+iOffset) -** can be determined using the [sqlite3_blob_bytes()] interface. -** -** ^An attempt to read from an expired [BLOB handle] fails with an -** error code of [SQLITE_ABORT]. -** -** ^(On success, sqlite3_blob_read() returns SQLITE_OK. -** Otherwise, an [error code] or an [extended error code] is returned.)^ -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -** -** See also: [sqlite3_blob_write()]. -*/ -SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); - -/* -** CAPI3REF: Write Data Into A BLOB Incrementally -** -** ^This function is used to write data into an open [BLOB handle] from a -** caller-supplied buffer. ^N bytes of data are copied from the buffer Z -** into the open BLOB, starting at offset iOffset. -** -** ^If the [BLOB handle] passed as the first argument was not opened for -** writing (the flags parameter to [sqlite3_blob_open()] was zero), -** this function returns [SQLITE_READONLY]. -** -** ^This function may only modify the contents of the BLOB; it is -** not possible to increase the size of a BLOB using this API. -** ^If offset iOffset is less than N bytes from the end of the BLOB, -** [SQLITE_ERROR] is returned and no data is written. ^If N is -** less than zero [SQLITE_ERROR] is returned and no data is written. -** The size of the BLOB (and hence the maximum value of N+iOffset) -** can be determined using the [sqlite3_blob_bytes()] interface. -** -** ^An attempt to write to an expired [BLOB handle] fails with an -** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred -** before the [BLOB handle] expired are not rolled back by the -** expiration of the handle, though of course those changes might -** have been overwritten by the statement that expired the BLOB handle -** or by other independent statements. -** -** ^(On success, sqlite3_blob_write() returns SQLITE_OK. -** Otherwise, an [error code] or an [extended error code] is returned.)^ -** -** This routine only works on a [BLOB handle] which has been created -** by a prior successful call to [sqlite3_blob_open()] and which has not -** been closed by [sqlite3_blob_close()]. Passing any other pointer in -** to this routine results in undefined and probably undesirable behavior. -** -** See also: [sqlite3_blob_read()]. -*/ -SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); - -/* -** CAPI3REF: Virtual File System Objects -** -** A virtual filesystem (VFS) is an [sqlite3_vfs] object -** that SQLite uses to interact -** with the underlying operating system. Most SQLite builds come with a -** single default VFS that is appropriate for the host computer. -** New VFSes can be registered and existing VFSes can be unregistered. -** The following interfaces are provided. -** -** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. -** ^Names are case sensitive. -** ^Names are zero-terminated UTF-8 strings. -** ^If there is no match, a NULL pointer is returned. -** ^If zVfsName is NULL then the default VFS is returned. -** -** ^New VFSes are registered with sqlite3_vfs_register(). -** ^Each new VFS becomes the default VFS if the makeDflt flag is set. -** ^The same VFS can be registered multiple times without injury. -** ^To make an existing VFS into the default VFS, register it again -** with the makeDflt flag set. If two different VFSes with the -** same name are registered, the behavior is undefined. If a -** VFS is registered with a name that is NULL or an empty string, -** then the behavior is undefined. -** -** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. -** ^(If the default VFS is unregistered, another VFS is chosen as -** the default. The choice for the new VFS is arbitrary.)^ -*/ -SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); -SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); -SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); - -/* -** CAPI3REF: Mutexes -** -** The SQLite core uses these routines for thread -** synchronization. Though they are intended for internal -** use by SQLite, code that links against SQLite is -** permitted to use any of these routines. -** -** The SQLite source code contains multiple implementations -** of these mutex routines. An appropriate implementation -** is selected automatically at compile-time. ^(The following -** implementations are available in the SQLite core: -** -**
    -**
  • SQLITE_MUTEX_OS2 -**
  • SQLITE_MUTEX_PTHREAD -**
  • SQLITE_MUTEX_W32 -**
  • SQLITE_MUTEX_NOOP -**
)^ -** -** ^The SQLITE_MUTEX_NOOP implementation is a set of routines -** that does no real locking and is appropriate for use in -** a single-threaded application. ^The SQLITE_MUTEX_OS2, -** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations -** are appropriate for use on OS/2, Unix, and Windows. -** -** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor -** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex -** implementation is included with the library. In this case the -** application must supply a custom mutex implementation using the -** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function -** before calling sqlite3_initialize() or any other public sqlite3_ -** function that calls sqlite3_initialize().)^ -** -** ^The sqlite3_mutex_alloc() routine allocates a new -** mutex and returns a pointer to it. ^If it returns NULL -** that means that a mutex could not be allocated. ^SQLite -** will unwind its stack and return an error. ^(The argument -** to sqlite3_mutex_alloc() is one of these integer constants: -** -**
    -**
  • SQLITE_MUTEX_FAST -**
  • SQLITE_MUTEX_RECURSIVE -**
  • SQLITE_MUTEX_STATIC_MASTER -**
  • SQLITE_MUTEX_STATIC_MEM -**
  • SQLITE_MUTEX_STATIC_MEM2 -**
  • SQLITE_MUTEX_STATIC_PRNG -**
  • SQLITE_MUTEX_STATIC_LRU -**
  • SQLITE_MUTEX_STATIC_LRU2 -**
)^ -** -** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) -** cause sqlite3_mutex_alloc() to create -** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE -** is used but not necessarily so when SQLITE_MUTEX_FAST is used. -** The mutex implementation does not need to make a distinction -** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does -** not want to. ^SQLite will only request a recursive mutex in -** cases where it really needs one. ^If a faster non-recursive mutex -** implementation is available on the host platform, the mutex subsystem -** might return such a mutex in response to SQLITE_MUTEX_FAST. -** -** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other -** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return -** a pointer to a static preexisting mutex. ^Six static mutexes are -** used by the current version of SQLite. Future versions of SQLite -** may add additional static mutexes. Static mutexes are for internal -** use by SQLite only. Applications that use SQLite mutexes should -** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or -** SQLITE_MUTEX_RECURSIVE. -** -** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST -** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() -** returns a different mutex on every call. ^But for the static -** mutex types, the same mutex is returned on every call that has -** the same type number. -** -** ^The sqlite3_mutex_free() routine deallocates a previously -** allocated dynamic mutex. ^SQLite is careful to deallocate every -** dynamic mutex that it allocates. The dynamic mutexes must not be in -** use when they are deallocated. Attempting to deallocate a static -** mutex results in undefined behavior. ^SQLite never deallocates -** a static mutex. -** -** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt -** to enter a mutex. ^If another thread is already within the mutex, -** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return -** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] -** upon successful entry. ^(Mutexes created using -** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. -** In such cases the, -** mutex must be exited an equal number of times before another thread -** can enter.)^ ^(If the same thread tries to enter any other -** kind of mutex more than once, the behavior is undefined. -** SQLite will never exhibit -** such behavior in its own use of mutexes.)^ -** -** ^(Some systems (for example, Windows 95) do not support the operation -** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() -** will always return SQLITE_BUSY. The SQLite core only ever uses -** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^ -** -** ^The sqlite3_mutex_leave() routine exits a mutex that was -** previously entered by the same thread. ^(The behavior -** is undefined if the mutex is not currently entered by the -** calling thread or is not currently allocated. SQLite will -** never do either.)^ -** -** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or -** sqlite3_mutex_leave() is a NULL pointer, then all three routines -** behave as no-ops. -** -** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. -*/ -SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); -SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); -SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); -SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); -SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); - -/* -** CAPI3REF: Mutex Methods Object -** EXPERIMENTAL -** -** An instance of this structure defines the low-level routines -** used to allocate and use mutexes. -** -** Usually, the default mutex implementations provided by SQLite are -** sufficient, however the user has the option of substituting a custom -** implementation for specialized deployments or systems for which SQLite -** does not provide a suitable implementation. In this case, the user -** creates and populates an instance of this structure to pass -** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. -** Additionally, an instance of this structure can be used as an -** output variable when querying the system for the current mutex -** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. -** -** ^The xMutexInit method defined by this structure is invoked as -** part of system initialization by the sqlite3_initialize() function. -** ^The xMutexInit routine is calle by SQLite exactly once for each -** effective call to [sqlite3_initialize()]. -** -** ^The xMutexEnd method defined by this structure is invoked as -** part of system shutdown by the sqlite3_shutdown() function. The -** implementation of this method is expected to release all outstanding -** resources obtained by the mutex methods implementation, especially -** those obtained by the xMutexInit method. ^The xMutexEnd() -** interface is invoked exactly once for each call to [sqlite3_shutdown()]. -** -** ^(The remaining seven methods defined by this structure (xMutexAlloc, -** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and -** xMutexNotheld) implement the following interfaces (respectively): -** -**
    -**
  • [sqlite3_mutex_alloc()]
    • -**
  • [sqlite3_mutex_free()]
    • -**
  • [sqlite3_mutex_enter()]
    • -**
  • [sqlite3_mutex_try()]
    • -**
  • [sqlite3_mutex_leave()]
    • -**
  • [sqlite3_mutex_held()]
    • -**
  • [sqlite3_mutex_notheld()]
    • -**
)^ -** -** The only difference is that the public sqlite3_XXX functions enumerated -** above silently ignore any invocations that pass a NULL pointer instead -** of a valid mutex handle. The implementations of the methods defined -** by this structure are not required to handle this case, the results -** 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 -** 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; -struct sqlite3_mutex_methods { - int (*xMutexInit)(void); - int (*xMutexEnd)(void); - sqlite3_mutex *(*xMutexAlloc)(int); - void (*xMutexFree)(sqlite3_mutex *); - void (*xMutexEnter)(sqlite3_mutex *); - int (*xMutexTry)(sqlite3_mutex *); - void (*xMutexLeave)(sqlite3_mutex *); - int (*xMutexHeld)(sqlite3_mutex *); - int (*xMutexNotheld)(sqlite3_mutex *); -}; - -/* -** CAPI3REF: Mutex Verification Routines -** -** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines -** are intended for use inside assert() statements. ^The SQLite core -** never uses these routines except inside an assert() and applications -** are advised to follow the lead of the core. ^The SQLite core only -** provides implementations for these routines when it is compiled -** with the SQLITE_DEBUG flag. ^External mutex implementations -** are only required to provide these routines if SQLITE_DEBUG is -** defined and if NDEBUG is not defined. -** -** ^These routines should return true if the mutex in their argument -** is held or not held, respectively, by the calling thread. -** -** ^The implementation is not required to provided versions of these -** routines that actually work. If the implementation does not provide working -** versions of these routines, it should at least provide stubs that always -** return true so that one does not get spurious assertion failures. -** -** ^If the argument to sqlite3_mutex_held() is a NULL pointer then -** the routine should return 1. This seems counter-intuitive since -** clearly the mutex cannot be held if it does not exist. But the -** the reason the mutex does not exist is because the build is not -** using mutexes. And we do not want the assert() containing the -** call to sqlite3_mutex_held() to fail, so a non-zero return is -** the appropriate thing to do. ^The sqlite3_mutex_notheld() -** interface should also return 1 when given a NULL pointer. -*/ -#ifndef NDEBUG -SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); -SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); -#endif - -/* -** CAPI3REF: Mutex Types -** -** The [sqlite3_mutex_alloc()] interface takes a single argument -** which is one of these integer constants. -** -** The set of static mutexes may change from one SQLite release to the -** next. Applications that override the built-in mutex logic must be -** prepared to accommodate additional static mutexes. -*/ -#define SQLITE_MUTEX_FAST 0 -#define SQLITE_MUTEX_RECURSIVE 1 -#define SQLITE_MUTEX_STATIC_MASTER 2 -#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ -#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ -#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ -#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ -#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ -#define SQLITE_MUTEX_STATIC_LRU2 7 /* lru page list */ - -/* -** CAPI3REF: Retrieve the mutex for a database connection -** -** ^This interface returns a pointer the [sqlite3_mutex] object that -** serializes access to the [database connection] given in the argument -** when the [threading mode] is Serialized. -** ^If the [threading mode] is Single-thread or Multi-thread then this -** routine returns a NULL pointer. -*/ -SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); - -/* -** CAPI3REF: Low-Level Control Of Database Files -** -** ^The [sqlite3_file_control()] interface makes a direct call to the -** xFileControl method for the [sqlite3_io_methods] object associated -** with a particular database identified by the second argument. ^The -** name of the database "main" for the main database or "temp" for the -** TEMP database, or the name that appears after the AS keyword for -** databases that are added using the [ATTACH] SQL command. -** ^A NULL pointer can be used in place of "main" to refer to the -** main database file. -** ^The third and fourth parameters to this routine -** are passed directly through to the second and third parameters of -** the xFileControl method. ^The return value of the xFileControl -** method becomes the return value of this routine. -** -** ^If the second parameter (zDbName) does not match the name of any -** open database file, then SQLITE_ERROR is returned. ^This error -** code is not remembered and will not be recalled by [sqlite3_errcode()] -** or [sqlite3_errmsg()]. The underlying xFileControl method might -** also return SQLITE_ERROR. There is no way to distinguish between -** an incorrect zDbName and an SQLITE_ERROR return from the underlying -** xFileControl method. -** -** See also: [SQLITE_FCNTL_LOCKSTATE] -*/ -SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); - -/* -** CAPI3REF: Testing Interface -** -** ^The sqlite3_test_control() interface is used to read out internal -** state of SQLite and to inject faults into SQLite for testing -** purposes. ^The first parameter is an operation code that determines -** the number, meaning, and operation of all subsequent parameters. -** -** This interface is not for use by applications. It exists solely -** for verifying the correct operation of the SQLite library. Depending -** on how the SQLite library is compiled, this interface might not exist. -** -** The details of the operation codes, their meanings, the parameters -** they take, and what they do are all subject to change without notice. -** Unlike most of the SQLite API, this function is not guaranteed to -** operate consistently from one release to the next. -*/ -SQLITE_API int sqlite3_test_control(int op, ...); - -/* -** CAPI3REF: Testing Interface Operation Codes -** -** These constants are the valid operation code parameters used -** as the first argument to [sqlite3_test_control()]. -** -** These parameters and their meanings are subject to change -** without notice. These values are for testing purposes only. -** Applications should not use any of these parameters or the -** [sqlite3_test_control()] interface. -*/ -#define SQLITE_TESTCTRL_FIRST 5 -#define SQLITE_TESTCTRL_PRNG_SAVE 5 -#define SQLITE_TESTCTRL_PRNG_RESTORE 6 -#define SQLITE_TESTCTRL_PRNG_RESET 7 -#define SQLITE_TESTCTRL_BITVEC_TEST 8 -#define SQLITE_TESTCTRL_FAULT_INSTALL 9 -#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 -#define SQLITE_TESTCTRL_PENDING_BYTE 11 -#define SQLITE_TESTCTRL_ASSERT 12 -#define SQLITE_TESTCTRL_ALWAYS 13 -#define SQLITE_TESTCTRL_RESERVE 14 -#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 -#define SQLITE_TESTCTRL_ISKEYWORD 16 -#define SQLITE_TESTCTRL_LAST 16 - -/* -** CAPI3REF: SQLite Runtime Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about the preformance of SQLite, and optionally to reset various -** highwater marks. ^The first argument is an integer code for -** the specific parameter to measure. ^(Recognized integer codes -** are of the form [SQLITE_STATUS_MEMORY_USED | SQLITE_STATUS_...].)^ -** ^The current value of the parameter is returned into *pCurrent. -** ^The highest recorded value is returned in *pHighwater. ^If the -** resetFlag is true, then the highest record value is reset after -** *pHighwater is written. ^(Some parameters do not record the highest -** value. For those parameters -** nothing is written into *pHighwater and the resetFlag is ignored.)^ -** ^(Other parameters record only the highwater mark and not the current -** value. For these latter parameters nothing is written into *pCurrent.)^ -** -** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a -** non-zero [error code] on failure. -** -** This routine is threadsafe but is not atomic. This routine can be -** called while other threads are running the same or different SQLite -** interfaces. However the values returned in *pCurrent and -** *pHighwater reflect the status of SQLite at different points in time -** and it is possible that another thread might change the parameter -** in between the times when *pCurrent and *pHighwater are written. -** -** See also: [sqlite3_db_status()] -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); - - -/* -** CAPI3REF: Status Parameters -** EXPERIMENTAL -** -** These integer constants designate various run-time status parameters -** that can be returned by [sqlite3_status()]. -** -**
-** ^(
SQLITE_STATUS_MEMORY_USED
-**
This parameter is the current amount of memory checked out -** using [sqlite3_malloc()], either directly or indirectly. The -** figure includes calls made to [sqlite3_malloc()] by the application -** and internal memory usage by the SQLite library. Scratch memory -** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache -** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in -** this parameter. The amount returned is the sum of the allocation -** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ -** -** ^(
SQLITE_STATUS_MALLOC_SIZE
-**
This parameter records the largest memory allocation request -** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their -** internal equivalents). Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_USED
-**
This parameter returns the number of pages used out of the -** [pagecache memory allocator] that was configured using -** [SQLITE_CONFIG_PAGECACHE]. The -** value returned is in pages, not in bytes.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
-**
This parameter returns the number of bytes of page cache -** allocation which could not be statisfied by the [SQLITE_CONFIG_PAGECACHE] -** buffer and where forced to overflow to [sqlite3_malloc()]. The -** returned value includes allocations that overflowed because they -** where too large (they were larger than the "sz" parameter to -** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because -** no space was left in the page cache.
)^ -** -** ^(
SQLITE_STATUS_PAGECACHE_SIZE
-**
This parameter records the largest memory allocation request -** handed to [pagecache memory allocator]. Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_USED
-**
This parameter returns the number of allocations used out of the -** [scratch memory allocator] configured using -** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not -** in bytes. Since a single thread may only have one scratch allocation -** outstanding at time, this parameter also reports the number of threads -** using scratch memory at the same time.
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
-**
This parameter returns the number of bytes of scratch memory -** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH] -** buffer and where forced to overflow to [sqlite3_malloc()]. The values -** returned include overflows because the requested allocation was too -** larger (that is, because the requested allocation was larger than the -** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer -** slots were available. -**
)^ -** -** ^(
SQLITE_STATUS_SCRATCH_SIZE
-**
This parameter records the largest memory allocation request -** handed to [scratch memory allocator]. Only the value returned in the -** *pHighwater parameter to [sqlite3_status()] is of interest. -** The value written into the *pCurrent parameter is undefined.
)^ -** -** ^(
SQLITE_STATUS_PARSER_STACK
-**
This parameter records the deepest parser stack. It is only -** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ -**
-** -** New status parameters may be added from time to time. -*/ -#define SQLITE_STATUS_MEMORY_USED 0 -#define SQLITE_STATUS_PAGECACHE_USED 1 -#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 -#define SQLITE_STATUS_SCRATCH_USED 3 -#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 -#define SQLITE_STATUS_MALLOC_SIZE 5 -#define SQLITE_STATUS_PARSER_STACK 6 -#define SQLITE_STATUS_PAGECACHE_SIZE 7 -#define SQLITE_STATUS_SCRATCH_SIZE 8 - -/* -** CAPI3REF: Database Connection Status -** EXPERIMENTAL -** -** ^This interface is used to retrieve runtime status information -** about a single [database connection]. ^The first argument is the -** database connection object to be interrogated. ^The second argument -** is the parameter to interrogate. ^Currently, the only allowed value -** for the second parameter is [SQLITE_DBSTATUS_LOOKASIDE_USED]. -** Additional options will likely appear in future releases of SQLite. -** -** ^The current value of the requested parameter is written into *pCur -** and the highest instantaneous value is written into *pHiwtr. ^If -** the resetFlg is true, then the highest instantaneous value is -** reset back down to the current value. -** -** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); - -/* -** CAPI3REF: Status Parameters for database connections -** EXPERIMENTAL -** -** 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. -** -**
-** ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
-**
This parameter returns the number of lookaside memory slots currently -** checked out.
)^ -**
-*/ -#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 - - -/* -** CAPI3REF: Prepared Statement Status -** EXPERIMENTAL -** -** ^(Each prepared statement maintains various -** [SQLITE_STMTSTATUS_SORT | counters] that measure the number -** of times it has performed specific operations.)^ These counters can -** be used to monitor the performance characteristics of the prepared -** statements. For example, if the number of table steps greatly exceeds -** the number of table searches or result rows, that would tend to indicate -** that the prepared statement is using a full table scan rather than -** an index. -** -** ^(This interface is used to retrieve and reset counter values from -** a [prepared statement]. The first argument is the prepared statement -** object to be interrogated. The second argument -** is an integer code for a specific [SQLITE_STMTSTATUS_SORT | counter] -** to be interrogated.)^ -** ^The current value of the requested counter is returned. -** ^If the resetFlg is true, then the counter is reset to zero after this -** interface call returns. -** -** See also: [sqlite3_status()] and [sqlite3_db_status()]. -*/ -SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); - -/* -** CAPI3REF: Status Parameters for prepared statements -** EXPERIMENTAL -** -** These preprocessor macros define integer codes that name counter -** values associated with the [sqlite3_stmt_status()] interface. -** The meanings of the various counters are as follows: -** -**
-**
SQLITE_STMTSTATUS_FULLSCAN_STEP
-**
^This is the number of times that SQLite has stepped forward in -** a table as part of a full table scan. Large numbers for this counter -** may indicate opportunities for performance improvement through -** careful use of indices.
-** -**
SQLITE_STMTSTATUS_SORT
-**
^This is the number of sort operations that have occurred. -** A non-zero value in this counter may indicate an opportunity to -** improvement performance through careful use of indices.
-** -**
-*/ -#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 -#define SQLITE_STMTSTATUS_SORT 2 - -/* -** CAPI3REF: Custom Page Cache Object -** EXPERIMENTAL -** -** The sqlite3_pcache type is opaque. It is implemented by -** the pluggable module. The SQLite core has no knowledge of -** its size or internal structure and never deals with the -** sqlite3_pcache object except by holding and passing pointers -** to the object. -** -** See [sqlite3_pcache_methods] for additional information. -*/ -typedef struct sqlite3_pcache sqlite3_pcache; - -/* -** CAPI3REF: Application Defined Page Cache. -** KEYWORDS: {page cache} -** EXPERIMENTAL -** -** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can -** register an alternative page cache implementation by passing in an -** 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 -** from, or ready to be written to, the database file. By implementing a -** custom page cache using this API, an application can control more -** precisely the amount of memory consumed by SQLite, the way in which -** that memory is allocated and released, and the policies used to -** determine exactly which parts of a database file are cached and for -** how long. -** -** ^(The contents of the sqlite3_pcache_methods structure are copied to an -** 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()] -** (usually only once during the lifetime of the process). ^(The xInit() -** method is passed a copy of the sqlite3_pcache_methods.pArg value.)^ -** ^The xInit() method can set up up global structures and/or any mutexes -** required by the custom page cache implementation. -** -** ^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 -** be allocated by the cache. ^szPage will not be a power of two. ^szPage -** will the page size of the database file that is to be cached plus an -** 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 -** does not have to do anything special based with the value of bPurgeable; -** 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 -** suggested maximum cache-size (number of pages stored by) the cache -** instance passed as the first argument. This is the value configured using -** the SQLite "[PRAGMA cache_size]" command.)^ ^As with the bPurgeable -** parameter, the implementation is not required to do anything with this -** value; it is advisory only. -** -** ^The xPagecount() method should return the number of pages currently -** stored in the cache. -** -** ^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 -** 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 -** is considered to be "pinned". -** -** ^If the requested page is already in the page cache, then the page cache -** implementation must return a pointer to the page buffer with its content -** intact. ^(If the requested page is not already in the cache, then the -** behavior of the cache implementation is determined by the value of the -** createFlag parameter passed to xFetch, according to the following table: -** -** -**
createFlag Behaviour when page is not already in cache -**
0 Do not allocate a new page. Return NULL. -**
1 Allocate a new page if it easy and convenient to do so. -** Otherwise return NULL. -**
2 Make every effort to allocate a new page. Only return -** NULL if allocating a new page is effectively impossible. -**
)^ -** -** 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 -** 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 -** 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 -** zero, then the page is considered to be unpinned. ^The cache implementation -** may choose to evict unpinned pages at any time. -** -** ^(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 -** to xFetch().)^ -** -** ^The xRekey() method is used to change the key value associated with the -** page passed as the second argument from oldKey to newKey. ^If the cache -** previously contains an entry associated with newKey, it should be -** discarded. ^Any prior cache entry associated with newKey is guaranteed not -** to be pinned. -** -** ^When SQLite calls the xTruncate() method, the cache must discard all -** existing cache entries with page numbers (keys) greater than or equal -** to the value of the iLimit parameter passed to xTruncate(). ^If any -** of these pages are pinned, they are implicitly unpinned, meaning that -** they can be safely discarded. -** -** ^The xDestroy() method is used to delete a cache allocated by xCreate(). -** All resources associated with the specified cache should be freed. ^After -** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] -** handle invalid, and will not use it with any other sqlite3_pcache_methods -** functions. -*/ -typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; -struct sqlite3_pcache_methods { - void *pArg; - int (*xInit)(void*); - void (*xShutdown)(void*); - sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); - void (*xCachesize)(sqlite3_pcache*, int nCachesize); - int (*xPagecount)(sqlite3_pcache*); - void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); - void (*xUnpin)(sqlite3_pcache*, void*, int discard); - void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); - void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); - void (*xDestroy)(sqlite3_pcache*); -}; - -/* -** CAPI3REF: Online Backup Object -** EXPERIMENTAL -** -** The sqlite3_backup object records state information about an ongoing -** online backup operation. ^The sqlite3_backup object is created by -** a call to [sqlite3_backup_init()] and is destroyed by a call to -** [sqlite3_backup_finish()]. -** -** See Also: [Using the SQLite Online Backup API] -*/ -typedef struct sqlite3_backup sqlite3_backup; - -/* -** CAPI3REF: Online Backup API. -** EXPERIMENTAL -** -** The backup API copies the content of one database into another. -** It is useful either for creating backups of databases or -** for copying in-memory databases to or from persistent files. -** -** See Also: [Using the SQLite Online Backup API] -** -** ^Exclusive access is required to the destination database for the -** duration of the operation. ^However the source database is only -** read-locked while it is actually being read; it is not locked -** continuously for the entire backup operation. ^Thus, the backup may be -** performed on a live source database without preventing other users from -** reading or writing to the source database while the backup is underway. -** -** ^(To perform a backup operation: -**
    -**
  1. sqlite3_backup_init() is called once to initialize the -** backup, -**
  2. sqlite3_backup_step() is called one or more times to transfer -** the data between the two databases, and finally -**
  3. sqlite3_backup_finish() is called to release all resources -** associated with the backup operation. -**
)^ -** There should be exactly one call to sqlite3_backup_finish() for each -** successful call to sqlite3_backup_init(). -** -** sqlite3_backup_init() -** -** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the -** [database connection] associated with the destination database -** and the database name, respectively. -** ^The database name is "main" for the main database, "temp" for the -** temporary database, or the name specified after the AS keyword in -** an [ATTACH] statement for an attached database. -** ^The S and M arguments passed to -** sqlite3_backup_init(D,N,S,M) identify the [database connection] -** and database name of the source database, respectively. -** ^The source and destination [database connections] (parameters S and D) -** must be different or else sqlite3_backup_init(D,N,S,M) will file with -** an error. -** -** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is -** returned and an error code and error message are store3d in the -** destination [database connection] D. -** ^The error code and message for the failed call to sqlite3_backup_init() -** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or -** [sqlite3_errmsg16()] functions. -** ^A successful call to sqlite3_backup_init() returns a pointer to an -** [sqlite3_backup] object. -** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and -** sqlite3_backup_finish() functions to perform the specified backup -** operation. -** -** sqlite3_backup_step() -** -** ^Function sqlite3_backup_step(B,N) will copy up to N pages between -** the source and destination databases specified by [sqlite3_backup] object B. -** ^If N is negative, all remaining source pages are copied. -** ^If sqlite3_backup_step(B,N) successfully copies N pages and there -** are still more pages to be copied, then the function resturns [SQLITE_OK]. -** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages -** from source to destination, then it returns [SQLITE_DONE]. -** ^If an error occurs while running sqlite3_backup_step(B,N), -** then an [error code] is returned. ^As well as [SQLITE_OK] and -** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], -** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an -** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. -** -** ^The sqlite3_backup_step() might return [SQLITE_READONLY] if the destination -** database was opened read-only or if -** the destination is an in-memory database with a different page size -** from the source database. -** -** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then -** the [sqlite3_busy_handler | busy-handler function] -** is invoked (if one is specified). ^If the -** busy-handler returns non-zero before the lock is available, then -** [SQLITE_BUSY] is returned to the caller. ^In this case the call to -** sqlite3_backup_step() can be retried later. ^If the source -** [database connection] -** is being used to write to the source database when sqlite3_backup_step() -** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this -** case the call to sqlite3_backup_step() can be retried later on. ^(If -** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or -** [SQLITE_READONLY] is returned, then -** there is no point in retrying the call to sqlite3_backup_step(). These -** errors are considered fatal.)^ The application must accept -** that the backup operation has failed and pass the backup operation handle -** to the sqlite3_backup_finish() to release associated resources. -** -** ^The first call to sqlite3_backup_step() obtains an exclusive lock -** on the destination file. ^The exclusive lock is not released until either -** sqlite3_backup_finish() is called or the backup operation is complete -** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to -** sqlite3_backup_step() obtains a [shared lock] on the source database that -** lasts for the duration of the sqlite3_backup_step() call. -** ^Because the source database is not locked between calls to -** sqlite3_backup_step(), the source database may be modified mid-way -** through the backup process. ^If the source database is modified by an -** external process or via a database connection other than the one being -** used by the backup operation, then the backup will be automatically -** restarted by the next call to sqlite3_backup_step(). ^If the source -** database is modified by the using the same database connection as is used -** by the backup operation, then the backup database is automatically -** updated at the same time. -** -** sqlite3_backup_finish() -** -** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the -** application wishes to abandon the backup operation, the application -** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). -** ^The sqlite3_backup_finish() interfaces releases all -** resources associated with the [sqlite3_backup] object. -** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any -** active write-transaction on the destination database is rolled back. -** The [sqlite3_backup] object is invalid -** and may not be used following a call to sqlite3_backup_finish(). -** -** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no -** sqlite3_backup_step() errors occurred, regardless or whether or not -** sqlite3_backup_step() completed. -** ^If an out-of-memory condition or IO error occurred during any prior -** sqlite3_backup_step() call on the same [sqlite3_backup] object, then -** sqlite3_backup_finish() returns the corresponding [error code]. -** -** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() -** is not a permanent error and does not affect the return value of -** sqlite3_backup_finish(). -** -** sqlite3_backup_remaining(), sqlite3_backup_pagecount() -** -** ^Each call to sqlite3_backup_step() sets two values inside -** the [sqlite3_backup] object: the number of pages still to be backed -** up and the total number of pages in the source databae file. -** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces -** retrieve these two values, respectively. -** -** ^The values returned by these functions are only updated by -** sqlite3_backup_step(). ^If the source database is modified during a backup -** operation, then the values are not updated to account for any extra -** pages that need to be updated or the size of the source database file -** changing. -** -** Concurrent Usage of Database Handles -** -** ^The source [database connection] may be used by the application for other -** purposes while a backup operation is underway or being initialized. -** ^If SQLite is compiled and configured to support threadsafe database -** connections, then the source database connection may be used concurrently -** from within other threads. -** -** However, the application must guarantee that the destination -** [database connection] is not passed to any other API (by any thread) after -** sqlite3_backup_init() is called and before the corresponding call to -** sqlite3_backup_finish(). SQLite does not currently check to see -** if the application incorrectly accesses the destination [database connection] -** and so no error code is reported, but the operations may malfunction -** nevertheless. Use of the destination database connection while a -** backup is in progress might also also cause a mutex deadlock. -** -** If running in [shared cache mode], the application must -** guarantee that the shared cache used by the destination database -** is not accessed while the backup is running. In practice this means -** that the application must guarantee that the disk file being -** backed up to is not accessed by any connection within the process, -** not just the specific connection that was passed to sqlite3_backup_init(). -** -** The [sqlite3_backup] object itself is partially threadsafe. Multiple -** threads may safely make multiple concurrent calls to sqlite3_backup_step(). -** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() -** APIs are not strictly speaking threadsafe. If they are invoked at the -** same time as another thread is invoking sqlite3_backup_step() it is -** possible that they return invalid values. -*/ -SQLITE_API sqlite3_backup *sqlite3_backup_init( - sqlite3 *pDest, /* Destination database handle */ - const char *zDestName, /* Destination database name */ - sqlite3 *pSource, /* Source database handle */ - const char *zSourceName /* Source database name */ -); -SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); -SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); -SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); -SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); - -/* -** CAPI3REF: Unlock Notification -** EXPERIMENTAL -** -** ^When running in shared-cache mode, a database operation may fail with -** an [SQLITE_LOCKED] error if the required locks on the shared-cache or -** individual tables within the shared-cache cannot be obtained. See -** [SQLite Shared-Cache Mode] for a description of shared-cache locking. -** ^This API may be used to register a callback that SQLite will invoke -** when the connection currently holding the required lock relinquishes it. -** ^This API is only available if the library was compiled with the -** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. -** -** See Also: [Using the SQLite Unlock Notification Feature]. -** -** ^Shared-cache locks are released when a database connection concludes -** its current transaction, either by committing it or rolling it back. -** -** ^When a connection (known as the blocked connection) fails to obtain a -** shared-cache lock and SQLITE_LOCKED is returned to the caller, the -** identity of the database connection (the blocking connection) that -** has locked the required resource is stored internally. ^After an -** application receives an SQLITE_LOCKED error, it may call the -** sqlite3_unlock_notify() method with the blocked connection handle as -** the first argument to register for a callback that will be invoked -** when the blocking connections current transaction is concluded. ^The -** callback is invoked from within the [sqlite3_step] or [sqlite3_close] -** call that concludes the blocking connections transaction. -** -** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, -** there is a chance that the blocking connection will have already -** concluded its transaction by the time sqlite3_unlock_notify() is invoked. -** If this happens, then the specified callback is invoked immediately, -** from within the call to sqlite3_unlock_notify().)^ -** -** ^If the blocked connection is attempting to obtain a write-lock on a -** shared-cache table, and more than one other connection currently holds -** a read-lock on the same table, then SQLite arbitrarily selects one of -** the other connections to use as the blocking connection. -** -** ^(There may be at most one unlock-notify callback registered by a -** blocked connection. If sqlite3_unlock_notify() is called when the -** blocked connection already has a registered unlock-notify callback, -** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is -** called with a NULL pointer as its second argument, then any existing -** unlock-notify callback is cancelled. ^The blocked connections -** unlock-notify callback may also be canceled by closing the blocked -** connection using [sqlite3_close()]. -** -** The unlock-notify callback is not reentrant. If an application invokes -** any sqlite3_xxx API functions from within an unlock-notify callback, a -** crash or deadlock may be the result. -** -** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always -** returns SQLITE_OK. -** -** Callback Invocation Details -** -** When an unlock-notify callback is registered, the application provides a -** single void* pointer that is passed to the callback when it is invoked. -** However, the signature of the callback function allows SQLite to pass -** it an array of void* context pointers. The first argument passed to -** an unlock-notify callback is a pointer to an array of void* pointers, -** and the second is the number of entries in the array. -** -** When a blocking connections transaction is concluded, there may be -** more than one blocked connection that has registered for an unlock-notify -** callback. ^If two or more such blocked connections have specified the -** same callback function, then instead of invoking the callback function -** multiple times, it is invoked once with the set of void* context pointers -** specified by the blocked connections bundled together into an array. -** This gives the application an opportunity to prioritize any actions -** related to the set of unblocked database connections. -** -** Deadlock Detection -** -** Assuming that after registering for an unlock-notify callback a -** database waits for the callback to be issued before taking any further -** action (a reasonable assumption), then using this API may cause the -** application to deadlock. For example, if connection X is waiting for -** connection Y's transaction to be concluded, and similarly connection -** Y is waiting on connection X's transaction, then neither connection -** will proceed and the system may remain deadlocked indefinitely. -** -** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock -** detection. ^If a given call to sqlite3_unlock_notify() would put the -** system in a deadlocked state, then SQLITE_LOCKED is returned and no -** unlock-notify callback is registered. The system is said to be in -** a deadlocked state if connection A has registered for an unlock-notify -** callback on the conclusion of connection B's transaction, and connection -** B has itself registered for an unlock-notify callback when connection -** A's transaction is concluded. ^Indirect deadlock is also detected, so -** the system is also considered to be deadlocked if connection B has -** registered for an unlock-notify callback on the conclusion of connection -** C's transaction, where connection C is waiting on connection A. ^Any -** number of levels of indirection are allowed. -** -** The "DROP TABLE" Exception -** -** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost -** always appropriate to call sqlite3_unlock_notify(). There is however, -** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, -** SQLite checks if there are any currently executing SELECT statements -** that belong to the same connection. If there are, SQLITE_LOCKED is -** returned. In this case there is no "blocking connection", so invoking -** sqlite3_unlock_notify() results in the unlock-notify callback being -** invoked immediately. If the application then re-attempts the "DROP TABLE" -** or "DROP INDEX" query, an infinite loop might be the result. -** -** One way around this problem is to check the extended error code returned -** by an sqlite3_step() call. ^(If there is a blocking connection, then the -** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in -** the special "DROP TABLE/INDEX" case, the extended error code is just -** SQLITE_LOCKED.)^ -*/ -SQLITE_API int sqlite3_unlock_notify( - sqlite3 *pBlocked, /* Waiting connection */ - void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ - void *pNotifyArg /* Argument to pass to xNotify */ -); - - -/* -** CAPI3REF: String Comparison -** EXPERIMENTAL -** -** ^The [sqlite3_strnicmp()] API allows applications and extensions to -** compare the contents of two buffers containing UTF-8 strings in a -** case-indendent fashion, using the same definition of case independence -** that SQLite uses internally when comparing identifiers. -*/ -SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); - -/* -** CAPI3REF: Error Logging Interface -** EXPERIMENTAL -** -** ^The [sqlite3_log()] interface writes a message into the error log -** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. -** ^If logging is enabled, the zFormat string and subsequent arguments are -** passed through to [sqlite3_vmprintf()] to generate the final output string. -** -** The sqlite3_log() interface is intended for use by extensions such as -** virtual tables, collating functions, and SQL functions. While there is -** nothing to prevent an application from calling sqlite3_log(), doing so -** is considered bad form. -** -** The zFormat string must not be NULL. -** -** To avoid deadlocks and other threading problems, the sqlite3_log() routine -** will not use dynamically allocated memory. The log message is stored in -** a fixed-length buffer on the stack. If the log message is longer than -** a few hundred characters, it will be truncated to the length of the -** buffer. -*/ -SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); - -/* -** Undo the hack that converts floating point types to integer for -** builds on processors without floating point support. -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# undef double -#endif - -#if 0 -} /* End of the 'extern "C"' block */ -#endif -#endif - - -/************** End of sqlite3.h *********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include hash.h in the middle of sqliteInt.h ******************/ -/************** Begin file hash.h ********************************************/ -/* -** 2001 September 22 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This is the header file for the generic hash-table implemenation -** used in SQLite. -*/ -#ifndef _SQLITE_HASH_H_ -#define _SQLITE_HASH_H_ - -/* Forward declarations of structures. */ -typedef struct Hash Hash; -typedef struct HashElem HashElem; - -/* A complete hash table is an instance of the following structure. -** The internals of this structure are intended to be opaque -- client -** code should not attempt to access or modify the fields of this structure -** directly. Change this structure only by using the routines below. -** However, some of the "procedures" and "functions" for modifying and -** accessing this structure are really macros, so we can't really make -** this structure opaque. -** -** All elements of the hash table are on a single doubly-linked list. -** Hash.first points to the head of this list. -** -** There are Hash.htsize buckets. Each bucket points to a spot in -** the global doubly-linked list. The contents of the bucket are the -** element pointed to plus the next _ht.count-1 elements in the list. -** -** Hash.htsize and Hash.ht may be zero. In that case lookup is done -** by a linear search of the global list. For small tables, the -** Hash.ht table is never allocated because if there are few elements -** in the table, it is faster to do a linear search than to manage -** the hash table. -*/ -struct Hash { - unsigned int htsize; /* Number of buckets in the hash table */ - unsigned int count; /* Number of entries in this table */ - HashElem *first; /* The first element of the array */ - struct _ht { /* the hash table */ - int count; /* Number of entries with this hash */ - HashElem *chain; /* Pointer to first entry with this hash */ - } *ht; -}; - -/* Each element in the hash table is an instance of the following -** structure. All elements are stored on a single doubly-linked list. -** -** Again, this structure is intended to be opaque, but it can't really -** be opaque because it is used by macros. -*/ -struct HashElem { - HashElem *next, *prev; /* Next and previous elements in the table */ - void *data; /* Data associated with this element */ - const char *pKey; int nKey; /* Key associated with this element */ -}; - -/* -** Access routines. To delete, insert a NULL pointer. -*/ -SQLITE_PRIVATE void sqlite3HashInit(Hash*); -SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData); -SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey); -SQLITE_PRIVATE void sqlite3HashClear(Hash*); - -/* -** Macros for looping over all elements of a hash table. The idiom is -** like this: -** -** Hash h; -** HashElem *p; -** ... -** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ -** SomeStructure *pData = sqliteHashData(p); -** // do something with pData -** } -*/ -#define sqliteHashFirst(H) ((H)->first) -#define sqliteHashNext(E) ((E)->next) -#define sqliteHashData(E) ((E)->data) -/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ -/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ - -/* -** Number of entries in a hash table -*/ -/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ - -#endif /* _SQLITE_HASH_H_ */ - -/************** End of hash.h ************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include parse.h in the middle of sqliteInt.h *****************/ -/************** Begin file parse.h *******************************************/ -#define TK_SEMI 1 -#define TK_EXPLAIN 2 -#define TK_QUERY 3 -#define TK_PLAN 4 -#define TK_BEGIN 5 -#define TK_TRANSACTION 6 -#define TK_DEFERRED 7 -#define TK_IMMEDIATE 8 -#define TK_EXCLUSIVE 9 -#define TK_COMMIT 10 -#define TK_END 11 -#define TK_ROLLBACK 12 -#define TK_SAVEPOINT 13 -#define TK_RELEASE 14 -#define TK_TO 15 -#define TK_TABLE 16 -#define TK_CREATE 17 -#define TK_IF 18 -#define TK_NOT 19 -#define TK_EXISTS 20 -#define TK_TEMP 21 -#define TK_LP 22 -#define TK_RP 23 -#define TK_AS 24 -#define TK_COMMA 25 -#define TK_ID 26 -#define TK_INDEXED 27 -#define TK_ABORT 28 -#define TK_ACTION 29 -#define TK_AFTER 30 -#define TK_ANALYZE 31 -#define TK_ASC 32 -#define TK_ATTACH 33 -#define TK_BEFORE 34 -#define TK_BY 35 -#define TK_CASCADE 36 -#define TK_CAST 37 -#define TK_COLUMNKW 38 -#define TK_CONFLICT 39 -#define TK_DATABASE 40 -#define TK_DESC 41 -#define TK_DETACH 42 -#define TK_EACH 43 -#define TK_FAIL 44 -#define TK_FOR 45 -#define TK_IGNORE 46 -#define TK_INITIALLY 47 -#define TK_INSTEAD 48 -#define TK_LIKE_KW 49 -#define TK_MATCH 50 -#define TK_NO 51 -#define TK_KEY 52 -#define TK_OF 53 -#define TK_OFFSET 54 -#define TK_PRAGMA 55 -#define TK_RAISE 56 -#define TK_REPLACE 57 -#define TK_RESTRICT 58 -#define TK_ROW 59 -#define TK_TRIGGER 60 -#define TK_VACUUM 61 -#define TK_VIEW 62 -#define TK_VIRTUAL 63 -#define TK_REINDEX 64 -#define TK_RENAME 65 -#define TK_CTIME_KW 66 -#define TK_ANY 67 -#define TK_OR 68 -#define TK_AND 69 -#define TK_IS 70 -#define TK_BETWEEN 71 -#define TK_IN 72 -#define TK_ISNULL 73 -#define TK_NOTNULL 74 -#define TK_NE 75 -#define TK_EQ 76 -#define TK_GT 77 -#define TK_LE 78 -#define TK_LT 79 -#define TK_GE 80 -#define TK_ESCAPE 81 -#define TK_BITAND 82 -#define TK_BITOR 83 -#define TK_LSHIFT 84 -#define TK_RSHIFT 85 -#define TK_PLUS 86 -#define TK_MINUS 87 -#define TK_STAR 88 -#define TK_SLASH 89 -#define TK_REM 90 -#define TK_CONCAT 91 -#define TK_COLLATE 92 -#define TK_BITNOT 93 -#define TK_STRING 94 -#define TK_JOIN_KW 95 -#define TK_CONSTRAINT 96 -#define TK_DEFAULT 97 -#define TK_NULL 98 -#define TK_PRIMARY 99 -#define TK_UNIQUE 100 -#define TK_CHECK 101 -#define TK_REFERENCES 102 -#define TK_AUTOINCR 103 -#define TK_ON 104 -#define TK_INSERT 105 -#define TK_DELETE 106 -#define TK_UPDATE 107 -#define TK_SET 108 -#define TK_DEFERRABLE 109 -#define TK_FOREIGN 110 -#define TK_DROP 111 -#define TK_UNION 112 -#define TK_ALL 113 -#define TK_EXCEPT 114 -#define TK_INTERSECT 115 -#define TK_SELECT 116 -#define TK_DISTINCT 117 -#define TK_DOT 118 -#define TK_FROM 119 -#define TK_JOIN 120 -#define TK_USING 121 -#define TK_ORDER 122 -#define TK_GROUP 123 -#define TK_HAVING 124 -#define TK_LIMIT 125 -#define TK_WHERE 126 -#define TK_INTO 127 -#define TK_VALUES 128 -#define TK_INTEGER 129 -#define TK_FLOAT 130 -#define TK_BLOB 131 -#define TK_REGISTER 132 -#define TK_VARIABLE 133 -#define TK_CASE 134 -#define TK_WHEN 135 -#define TK_THEN 136 -#define TK_ELSE 137 -#define TK_INDEX 138 -#define TK_ALTER 139 -#define TK_ADD 140 -#define TK_TO_TEXT 141 -#define TK_TO_BLOB 142 -#define TK_TO_NUMERIC 143 -#define TK_TO_INT 144 -#define TK_TO_REAL 145 -#define TK_ISNOT 146 -#define TK_END_OF_FILE 147 -#define TK_ILLEGAL 148 -#define TK_SPACE 149 -#define TK_UNCLOSED_STRING 150 -#define TK_FUNCTION 151 -#define TK_COLUMN 152 -#define TK_AGG_FUNCTION 153 -#define TK_AGG_COLUMN 154 -#define TK_CONST_FUNC 155 -#define TK_UMINUS 156 -#define TK_UPLUS 157 - -/************** End of parse.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -#include -#include -#include -#include -#include - -/* -** If compiling for a processor that lacks floating point support, -** substitute integer for floating-point -*/ -#ifdef SQLITE_OMIT_FLOATING_POINT -# define double sqlite_int64 -# define LONGDOUBLE_TYPE sqlite_int64 -# ifndef SQLITE_BIG_DBL -# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) -# endif -# define SQLITE_OMIT_DATETIME_FUNCS 1 -# define SQLITE_OMIT_TRACE 1 -# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT -# undef SQLITE_HAVE_ISNAN -#endif -#ifndef SQLITE_BIG_DBL -# define SQLITE_BIG_DBL (1e99) -#endif - -/* -** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 -** afterward. Having this macro allows us to cause the C compiler -** to omit code used by TEMP tables without messy #ifndef statements. -*/ -#ifdef SQLITE_OMIT_TEMPDB -#define OMIT_TEMPDB 1 -#else -#define OMIT_TEMPDB 0 -#endif - -/* -** The "file format" number is an integer that is incremented whenever -** the VDBE-level file format changes. The following macros define the -** the default file format for new databases and the maximum file format -** that the library can read. -*/ -#define SQLITE_MAX_FILE_FORMAT 4 -#ifndef SQLITE_DEFAULT_FILE_FORMAT -# define SQLITE_DEFAULT_FILE_FORMAT 1 -#endif - -/* -** Determine whether triggers are recursive by default. This can be -** changed at run-time using a pragma. -*/ -#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS -# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 -#endif - -/* -** Provide a default value for SQLITE_TEMP_STORE in case it is not specified -** on the command-line -*/ -#ifndef SQLITE_TEMP_STORE -# define SQLITE_TEMP_STORE 1 -#endif - -/* -** GCC does not define the offsetof() macro so we'll have to do it -** ourselves. -*/ -#ifndef offsetof -#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) -#endif - -/* -** Check to see if this machine uses EBCDIC. (Yes, believe it or -** not, there are still machines out there that use EBCDIC.) -*/ -#if 'A' == '\301' -# define SQLITE_EBCDIC 1 -#else -# define SQLITE_ASCII 1 -#endif - -/* -** Integers of known sizes. These typedefs might change for architectures -** where the sizes very. Preprocessor macros are available so that the -** types can be conveniently redefined at compile-type. Like this: -** -** cc '-DUINTPTR_TYPE=long long int' ... -*/ -#ifndef UINT32_TYPE -# ifdef HAVE_UINT32_T -# define UINT32_TYPE uint32_t -# else -# define UINT32_TYPE unsigned int -# endif -#endif -#ifndef UINT16_TYPE -# ifdef HAVE_UINT16_T -# define UINT16_TYPE uint16_t -# else -# define UINT16_TYPE unsigned short int -# endif -#endif -#ifndef INT16_TYPE -# ifdef HAVE_INT16_T -# define INT16_TYPE int16_t -# else -# define INT16_TYPE short int -# endif -#endif -#ifndef UINT8_TYPE -# ifdef HAVE_UINT8_T -# define UINT8_TYPE uint8_t -# else -# define UINT8_TYPE unsigned char -# endif -#endif -#ifndef INT8_TYPE -# ifdef HAVE_INT8_T -# define INT8_TYPE int8_t -# else -# define INT8_TYPE signed char -# endif -#endif -#ifndef LONGDOUBLE_TYPE -# define LONGDOUBLE_TYPE long double -#endif -typedef sqlite_int64 i64; /* 8-byte signed integer */ -typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ -typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ -typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ -typedef INT16_TYPE i16; /* 2-byte signed integer */ -typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ -typedef INT8_TYPE i8; /* 1-byte signed integer */ - -/* -** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value -** that can be stored in a u32 without loss of data. The value -** is 0x00000000ffffffff. But because of quirks of some compilers, we -** have to specify the value in the less intuitive manner shown: -*/ -#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) - -/* -** Macros to determine whether the machine is big or little endian, -** evaluated at runtime. -*/ -#ifdef SQLITE_AMALGAMATION -SQLITE_PRIVATE const int sqlite3one = 1; -#else -SQLITE_PRIVATE const int sqlite3one; -#endif -#if defined(i386) || defined(__i386__) || defined(_M_IX86)\ - || defined(__x86_64) || defined(__x86_64__) -# define SQLITE_BIGENDIAN 0 -# define SQLITE_LITTLEENDIAN 1 -# define SQLITE_UTF16NATIVE SQLITE_UTF16LE -#else -# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) -# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) -# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) -#endif - -/* -** Constants for the largest and smallest possible 64-bit signed integers. -** These macros are designed to work correctly on both 32-bit and 64-bit -** compilers. -*/ -#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) -#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) - -/* -** Round up a number to the next larger multiple of 8. This is used -** to force 8-byte alignment on 64-bit architectures. -*/ -#define ROUND8(x) (((x)+7)&~7) - -/* -** Round down to the nearest multiple of 8 -*/ -#define ROUNDDOWN8(x) ((x)&~7) - -/* -** Assert that the pointer X is aligned to an 8-byte boundary. This -** macro is used only within assert() to verify that the code gets -** all alignment restrictions correct. -** -** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the -** underlying malloc() implemention might return us 4-byte aligned -** pointers. In that case, only verify 4-byte alignment. -*/ -#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC -# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) -#else -# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) -#endif - - -/* -** An instance of the following structure is used to store the busy-handler -** callback for a given sqlite handle. -** -** The sqlite.busyHandler member of the sqlite struct contains the busy -** callback for the database handle. Each pager opened via the sqlite -** handle is passed a pointer to sqlite.busyHandler. The busy-handler -** callback is currently invoked only from within pager.c. -*/ -typedef struct BusyHandler BusyHandler; -struct BusyHandler { - int (*xFunc)(void *,int); /* The busy callback */ - void *pArg; /* First arg to busy callback */ - int nBusy; /* Incremented with each busy call */ -}; - -/* -** Name of the master database table. The master database table -** is a special table that holds the names and attributes of all -** user tables and indices. -*/ -#define MASTER_NAME "sqlite_master" -#define TEMP_MASTER_NAME "sqlite_temp_master" - -/* -** The root-page of the master database table. -*/ -#define MASTER_ROOT 1 - -/* -** The name of the schema table. -*/ -#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) - -/* -** A convenience macro that returns the number of elements in -** an array. -*/ -#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) - -/* -** The following value as a destructor means to use sqlite3DbFree(). -** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT. -*/ -#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree) - -/* -** When SQLITE_OMIT_WSD is defined, it means that the target platform does -** not support Writable Static Data (WSD) such as global and static variables. -** All variables must either be on the stack or dynamically allocated from -** the heap. When WSD is unsupported, the variable declarations scattered -** throughout the SQLite code must become constants instead. The SQLITE_WSD -** macro is used for this purpose. And instead of referencing the variable -** directly, we use its constant as a key to lookup the run-time allocated -** buffer that holds real variable. The constant is also the initializer -** for the run-time allocated buffer. -** -** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL -** macros become no-ops and have zero performance impact. -*/ -#ifdef SQLITE_OMIT_WSD - #define SQLITE_WSD const - #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) - #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) -SQLITE_API int sqlite3_wsd_init(int N, int J); -SQLITE_API void *sqlite3_wsd_find(void *K, int L); -#else - #define SQLITE_WSD - #define GLOBAL(t,v) v - #define sqlite3GlobalConfig sqlite3Config -#endif - -/* -** The following macros are used to suppress compiler warnings and to -** make it clear to human readers when a function parameter is deliberately -** left unused within the body of a function. This usually happens when -** a function is called via a function pointer. For example the -** implementation of an SQL aggregate step callback may not use the -** parameter indicating the number of arguments passed to the aggregate, -** if it knows that this is enforced elsewhere. -** -** When a function parameter is not used at all within the body of a function, -** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. -** However, these macros may also be used to suppress warnings related to -** parameters that may or may not be used depending on compilation options. -** For example those parameters only used in assert() statements. In these -** cases the parameters are named as per the usual conventions. -*/ -#define UNUSED_PARAMETER(x) (void)(x) -#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) - -/* -** Forward references to structures -*/ -typedef struct AggInfo AggInfo; -typedef struct AuthContext AuthContext; -typedef struct AutoincInfo AutoincInfo; -typedef struct Bitvec Bitvec; -typedef struct CollSeq CollSeq; -typedef struct Column Column; -typedef struct Db Db; -typedef struct Schema Schema; -typedef struct Expr Expr; -typedef struct ExprList ExprList; -typedef struct ExprSpan ExprSpan; -typedef struct FKey FKey; -typedef struct FuncDef FuncDef; -typedef struct FuncDefHash FuncDefHash; -typedef struct IdList IdList; -typedef struct Index Index; -typedef struct IndexSample IndexSample; -typedef struct KeyClass KeyClass; -typedef struct KeyInfo KeyInfo; -typedef struct Lookaside Lookaside; -typedef struct LookasideSlot LookasideSlot; -typedef struct Module Module; -typedef struct NameContext NameContext; -typedef struct Parse Parse; -typedef struct RowSet RowSet; -typedef struct Savepoint Savepoint; -typedef struct Select Select; -typedef struct SrcList SrcList; -typedef struct StrAccum StrAccum; -typedef struct Table Table; -typedef struct TableLock TableLock; -typedef struct Token Token; -typedef struct Trigger Trigger; -typedef struct TriggerPrg TriggerPrg; -typedef struct TriggerStep TriggerStep; -typedef struct UnpackedRecord UnpackedRecord; -typedef struct VTable VTable; -typedef struct Walker Walker; -typedef struct WherePlan WherePlan; -typedef struct WhereInfo WhereInfo; -typedef struct WhereLevel WhereLevel; - -/* -** Defer sourcing vdbe.h and btree.h until after the "u8" and -** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque -** pointer types (i.e. FuncDef) defined above. -*/ -/************** Include btree.h in the middle of sqliteInt.h *****************/ -/************** Begin file btree.h *******************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the sqlite B-Tree file -** subsystem. See comments in the source code for a detailed description -** of what each interface routine does. -*/ -#ifndef _BTREE_H_ -#define _BTREE_H_ - -/* TODO: This definition is just included so other modules compile. It -** needs to be revisited. -*/ -#define SQLITE_N_BTREE_META 10 - -/* -** If defined as non-zero, auto-vacuum is enabled by default. Otherwise -** it must be turned on for each database using "PRAGMA auto_vacuum = 1". -*/ -#ifndef SQLITE_DEFAULT_AUTOVACUUM - #define SQLITE_DEFAULT_AUTOVACUUM 0 -#endif - -#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ -#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ -#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ - -/* -** Forward declarations of structure -*/ -typedef struct Btree Btree; -typedef struct BtCursor BtCursor; -typedef struct BtShared BtShared; -typedef struct BtreeMutexArray BtreeMutexArray; - -/* -** This structure records all of the Btrees that need to hold -** a mutex before we enter sqlite3VdbeExec(). The Btrees are -** are placed in aBtree[] in order of aBtree[]->pBt. That way, -** we can always lock and unlock them all quickly. -*/ -struct BtreeMutexArray { - int nMutex; - Btree *aBtree[SQLITE_MAX_ATTACHED+1]; -}; - - -SQLITE_PRIVATE int sqlite3BtreeOpen( - const char *zFilename, /* Name of database file to open */ - sqlite3 *db, /* Associated database connection */ - Btree **ppBtree, /* Return open Btree* here */ - int flags, /* Flags */ - int vfsFlags /* Flags passed through to VFS open */ -); - -/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the -** following values. -** -** NOTE: These values must match the corresponding PAGER_ values in -** pager.h. -*/ -#define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */ -#define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */ -#define BTREE_MEMORY 4 /* In-memory DB. No argument */ -#define BTREE_READONLY 8 /* Open the database in read-only mode */ -#define BTREE_READWRITE 16 /* Open for both reading and writing */ -#define BTREE_CREATE 32 /* Create the database if it does not exist */ - -SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int); -SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); -SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); -SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*); -SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); -SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); -SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); -SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*); -SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); -SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*); -SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); -SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags); -SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*); -SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*); -SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); -SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); -SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); -SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); -SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); - -SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); -SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); -SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); - -SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); - -/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR -** of the following flags: -*/ -#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ -#define BTREE_ZERODATA 2 /* Table has keys only - no data */ -#define BTREE_LEAFDATA 4 /* Data stored in leaves only. Implies INTKEY */ - -SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); -SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); -SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int); - -SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); -SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); - -/* -** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta -** should be one of the following values. The integer values are assigned -** to constants so that the offset of the corresponding field in an -** SQLite database header may be found using the following formula: -** -** offset = 36 + (idx * 4) -** -** For example, the free-page-count field is located at byte offset 36 of -** the database file header. The incr-vacuum-flag field is located at -** byte offset 64 (== 36+4*7). -*/ -#define BTREE_FREE_PAGE_COUNT 0 -#define BTREE_SCHEMA_VERSION 1 -#define BTREE_FILE_FORMAT 2 -#define BTREE_DEFAULT_CACHE_SIZE 3 -#define BTREE_LARGEST_ROOT_PAGE 4 -#define BTREE_TEXT_ENCODING 5 -#define BTREE_USER_VERSION 6 -#define BTREE_INCR_VACUUM 7 - -SQLITE_PRIVATE int sqlite3BtreeCursor( - Btree*, /* BTree containing table to open */ - int iTable, /* Index of root page */ - int wrFlag, /* 1 for writing. 0 for read-only */ - struct KeyInfo*, /* First argument to compare function */ - BtCursor *pCursor /* Space to write cursor structure */ -); -SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); -SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); - -SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( - BtCursor*, - UnpackedRecord *pUnKey, - i64 intKey, - int bias, - int *pRes -); -SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*, int*); -SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, - const void *pData, int nData, - int nZero, int bias, int seekResult); -SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); -SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes); -SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); -SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); -SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); -SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); -SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64); -SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*); - -SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); -SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); - -SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); -SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *); -SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); - -#ifndef NDEBUG -SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); -#endif - -#ifndef SQLITE_OMIT_BTREECOUNT -SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *); -#endif - -#ifdef SQLITE_TEST -SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); -SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); -#endif - -/* -** If we are not using shared cache, then there is no need to -** use mutexes to access the BtShared structures. So make the -** Enter and Leave procedures no-ops. -*/ -#ifndef SQLITE_OMIT_SHARED_CACHE -SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); -SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); -#else -# define sqlite3BtreeEnter(X) -# define sqlite3BtreeEnterAll(X) -#endif - -#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE -SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); -SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); -SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); -SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*); -SQLITE_PRIVATE void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*); -#ifndef NDEBUG - /* These routines are used inside assert() statements only. */ -SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); -SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); -#endif -#else - -# define sqlite3BtreeLeave(X) -# define sqlite3BtreeEnterCursor(X) -# define sqlite3BtreeLeaveCursor(X) -# define sqlite3BtreeLeaveAll(X) -# define sqlite3BtreeMutexArrayEnter(X) -# define sqlite3BtreeMutexArrayLeave(X) -# define sqlite3BtreeMutexArrayInsert(X,Y) - -# define sqlite3BtreeHoldsMutex(X) 1 -# define sqlite3BtreeHoldsAllMutexes(X) 1 -#endif - - -#endif /* _BTREE_H_ */ - -/************** End of btree.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include vdbe.h in the middle of sqliteInt.h ******************/ -/************** Begin file vdbe.h ********************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** Header file for the Virtual DataBase Engine (VDBE) -** -** This header defines the interface to the virtual database engine -** or VDBE. The VDBE implements an abstract machine that runs a -** simple program to access and modify the underlying database. -*/ -#ifndef _SQLITE_VDBE_H_ -#define _SQLITE_VDBE_H_ - -/* -** A single VDBE is an opaque structure named "Vdbe". Only routines -** in the source file sqliteVdbe.c are allowed to see the insides -** of this structure. -*/ -typedef struct Vdbe Vdbe; - -/* -** The names of the following types declared in vdbeInt.h are required -** for the VdbeOp definition. -*/ -typedef struct VdbeFunc VdbeFunc; -typedef struct Mem Mem; -typedef struct SubProgram SubProgram; - -/* -** A single instruction of the virtual machine has an opcode -** and as many as three operands. The instruction is recorded -** as an instance of the following structure: -*/ -struct VdbeOp { - u8 opcode; /* What operation to perform */ - signed char p4type; /* One of the P4_xxx constants for p4 */ - u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */ - u8 p5; /* Fifth parameter is an unsigned character */ - int p1; /* First operand */ - int p2; /* Second parameter (often the jump destination) */ - int p3; /* The third parameter */ - union { /* fourth parameter */ - int i; /* Integer value if p4type==P4_INT32 */ - void *p; /* Generic pointer */ - char *z; /* Pointer to data for string (char array) types */ - i64 *pI64; /* Used when p4type is P4_INT64 */ - double *pReal; /* Used when p4type is P4_REAL */ - FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ - VdbeFunc *pVdbeFunc; /* Used when p4type is P4_VDBEFUNC */ - CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ - Mem *pMem; /* Used when p4type is P4_MEM */ - VTable *pVtab; /* Used when p4type is P4_VTAB */ - KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ - int *ai; /* Used when p4type is P4_INTARRAY */ - SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ - } p4; -#ifdef SQLITE_DEBUG - char *zComment; /* Comment to improve readability */ -#endif -#ifdef VDBE_PROFILE - int cnt; /* Number of times this instruction was executed */ - u64 cycles; /* Total time spent executing this instruction */ -#endif -}; -typedef struct VdbeOp VdbeOp; - - -/* -** A sub-routine used to implement a trigger program. -*/ -struct SubProgram { - VdbeOp *aOp; /* Array of opcodes for sub-program */ - int nOp; /* Elements in aOp[] */ - int nMem; /* Number of memory cells required */ - int nCsr; /* Number of cursors required */ - int nRef; /* Number of pointers to this structure */ - void *token; /* id that may be used to recursive triggers */ -}; - -/* -** A smaller version of VdbeOp used for the VdbeAddOpList() function because -** it takes up less space. -*/ -struct VdbeOpList { - u8 opcode; /* What operation to perform */ - signed char p1; /* First operand */ - signed char p2; /* Second parameter (often the jump destination) */ - signed char p3; /* Third parameter */ -}; -typedef struct VdbeOpList VdbeOpList; - -/* -** Allowed values of VdbeOp.p4type -*/ -#define P4_NOTUSED 0 /* The P4 parameter is not used */ -#define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */ -#define P4_STATIC (-2) /* Pointer to a static string */ -#define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */ -#define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */ -#define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */ -#define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */ -#define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */ -#define P4_TRANSIENT (-9) /* P4 is a pointer to a transient string */ -#define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */ -#define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */ -#define P4_REAL (-12) /* P4 is a 64-bit floating point value */ -#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */ -#define P4_INT32 (-14) /* P4 is a 32-bit signed integer */ -#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */ -#define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */ - -/* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure -** is made. That copy is freed when the Vdbe is finalized. But if the -** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used. It still -** gets freed when the Vdbe is finalized so it still should be obtained -** from a single sqliteMalloc(). But no copy is made and the calling -** function should *not* try to free the KeyInfo. -*/ -#define P4_KEYINFO_HANDOFF (-16) -#define P4_KEYINFO_STATIC (-17) - -/* -** The Vdbe.aColName array contains 5n Mem structures, where n is the -** number of columns of data returned by the statement. -*/ -#define COLNAME_NAME 0 -#define COLNAME_DECLTYPE 1 -#define COLNAME_DATABASE 2 -#define COLNAME_TABLE 3 -#define COLNAME_COLUMN 4 -#ifdef SQLITE_ENABLE_COLUMN_METADATA -# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ -#else -# ifdef SQLITE_OMIT_DECLTYPE -# define COLNAME_N 1 /* Store only the name */ -# else -# define COLNAME_N 2 /* Store the name and decltype */ -# endif -#endif - -/* -** The following macro converts a relative address in the p2 field -** of a VdbeOp structure into a negative number so that -** sqlite3VdbeAddOpList() knows that the address is relative. Calling -** the macro again restores the address. -*/ -#define ADDR(X) (-1-(X)) - -/* -** The makefile scans the vdbe.c source file and creates the "opcodes.h" -** header file that defines a number for each opcode used by the VDBE. -*/ -/************** Include opcodes.h in the middle of vdbe.h ********************/ -/************** Begin file opcodes.h *****************************************/ -/* Automatically generated. Do not edit */ -/* See the mkopcodeh.awk script for details */ -#define OP_Goto 1 -#define OP_Gosub 2 -#define OP_Return 3 -#define OP_Yield 4 -#define OP_HaltIfNull 5 -#define OP_Halt 6 -#define OP_Integer 7 -#define OP_Int64 8 -#define OP_Real 130 /* same as TK_FLOAT */ -#define OP_String8 94 /* same as TK_STRING */ -#define OP_String 9 -#define OP_Null 10 -#define OP_Blob 11 -#define OP_Variable 12 -#define OP_Move 13 -#define OP_Copy 14 -#define OP_SCopy 15 -#define OP_ResultRow 16 -#define OP_Concat 91 /* same as TK_CONCAT */ -#define OP_Add 86 /* same as TK_PLUS */ -#define OP_Subtract 87 /* same as TK_MINUS */ -#define OP_Multiply 88 /* same as TK_STAR */ -#define OP_Divide 89 /* same as TK_SLASH */ -#define OP_Remainder 90 /* same as TK_REM */ -#define OP_CollSeq 17 -#define OP_Function 18 -#define OP_BitAnd 82 /* same as TK_BITAND */ -#define OP_BitOr 83 /* same as TK_BITOR */ -#define OP_ShiftLeft 84 /* same as TK_LSHIFT */ -#define OP_ShiftRight 85 /* same as TK_RSHIFT */ -#define OP_AddImm 20 -#define OP_MustBeInt 21 -#define OP_RealAffinity 22 -#define OP_ToText 141 /* same as TK_TO_TEXT */ -#define OP_ToBlob 142 /* same as TK_TO_BLOB */ -#define OP_ToNumeric 143 /* same as TK_TO_NUMERIC*/ -#define OP_ToInt 144 /* same as TK_TO_INT */ -#define OP_ToReal 145 /* same as TK_TO_REAL */ -#define OP_Eq 76 /* same as TK_EQ */ -#define OP_Ne 75 /* same as TK_NE */ -#define OP_Lt 79 /* same as TK_LT */ -#define OP_Le 78 /* same as TK_LE */ -#define OP_Gt 77 /* same as TK_GT */ -#define OP_Ge 80 /* same as TK_GE */ -#define OP_Permutation 23 -#define OP_Compare 24 -#define OP_Jump 25 -#define OP_And 69 /* same as TK_AND */ -#define OP_Or 68 /* same as TK_OR */ -#define OP_Not 19 /* same as TK_NOT */ -#define OP_BitNot 93 /* same as TK_BITNOT */ -#define OP_If 26 -#define OP_IfNot 27 -#define OP_IsNull 73 /* same as TK_ISNULL */ -#define OP_NotNull 74 /* same as TK_NOTNULL */ -#define OP_Column 28 -#define OP_Affinity 29 -#define OP_MakeRecord 30 -#define OP_Count 31 -#define OP_Savepoint 32 -#define OP_AutoCommit 33 -#define OP_Transaction 34 -#define OP_ReadCookie 35 -#define OP_SetCookie 36 -#define OP_VerifyCookie 37 -#define OP_OpenRead 38 -#define OP_OpenWrite 39 -#define OP_OpenEphemeral 40 -#define OP_OpenPseudo 41 -#define OP_Close 42 -#define OP_SeekLt 43 -#define OP_SeekLe 44 -#define OP_SeekGe 45 -#define OP_SeekGt 46 -#define OP_Seek 47 -#define OP_NotFound 48 -#define OP_Found 49 -#define OP_IsUnique 50 -#define OP_NotExists 51 -#define OP_Sequence 52 -#define OP_NewRowid 53 -#define OP_Insert 54 -#define OP_InsertInt 55 -#define OP_Delete 56 -#define OP_ResetCount 57 -#define OP_RowKey 58 -#define OP_RowData 59 -#define OP_Rowid 60 -#define OP_NullRow 61 -#define OP_Last 62 -#define OP_Sort 63 -#define OP_Rewind 64 -#define OP_Prev 65 -#define OP_Next 66 -#define OP_IdxInsert 67 -#define OP_IdxDelete 70 -#define OP_IdxRowid 71 -#define OP_IdxLT 72 -#define OP_IdxGE 81 -#define OP_Destroy 92 -#define OP_Clear 95 -#define OP_CreateIndex 96 -#define OP_CreateTable 97 -#define OP_ParseSchema 98 -#define OP_LoadAnalysis 99 -#define OP_DropTable 100 -#define OP_DropIndex 101 -#define OP_DropTrigger 102 -#define OP_IntegrityCk 103 -#define OP_RowSetAdd 104 -#define OP_RowSetRead 105 -#define OP_RowSetTest 106 -#define OP_Program 107 -#define OP_Param 108 -#define OP_FkCounter 109 -#define OP_FkIfZero 110 -#define OP_MemMax 111 -#define OP_IfPos 112 -#define OP_IfNeg 113 -#define OP_IfZero 114 -#define OP_AggStep 115 -#define OP_AggFinal 116 -#define OP_Vacuum 117 -#define OP_IncrVacuum 118 -#define OP_Expire 119 -#define OP_TableLock 120 -#define OP_VBegin 121 -#define OP_VCreate 122 -#define OP_VDestroy 123 -#define OP_VOpen 124 -#define OP_VFilter 125 -#define OP_VColumn 126 -#define OP_VNext 127 -#define OP_VRename 128 -#define OP_VUpdate 129 -#define OP_Pagecount 131 -#define OP_Trace 132 -#define OP_Noop 133 -#define OP_Explain 134 - -/* The following opcode values are never used */ -#define OP_NotUsed_135 135 -#define OP_NotUsed_136 136 -#define OP_NotUsed_137 137 -#define OP_NotUsed_138 138 -#define OP_NotUsed_139 139 -#define OP_NotUsed_140 140 - - -/* Properties such as "out2" or "jump" that are specified in -** comments following the "case" for each opcode in the vdbe.c -** are encoded into bitvectors as follows: -*/ -#define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */ -#define OPFLG_OUT2_PRERELEASE 0x0002 /* out2-prerelease: */ -#define OPFLG_IN1 0x0004 /* in1: P1 is an input */ -#define OPFLG_IN2 0x0008 /* in2: P2 is an input */ -#define OPFLG_IN3 0x0010 /* in3: P3 is an input */ -#define OPFLG_OUT2 0x0020 /* out2: P2 is an output */ -#define OPFLG_OUT3 0x0040 /* out3: P3 is an output */ -#define OPFLG_INITIALIZER {\ -/* 0 */ 0x00, 0x01, 0x05, 0x04, 0x04, 0x10, 0x00, 0x02,\ -/* 8 */ 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x24, 0x24,\ -/* 16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\ -/* 24 */ 0x00, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02,\ -/* 32 */ 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00, 0x00,\ -/* 40 */ 0x00, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x08,\ -/* 48 */ 0x11, 0x11, 0x11, 0x11, 0x02, 0x02, 0x00, 0x00,\ -/* 56 */ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x01,\ -/* 64 */ 0x01, 0x01, 0x01, 0x08, 0x4c, 0x4c, 0x00, 0x02,\ -/* 72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\ -/* 80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\ -/* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x02, 0x24, 0x02, 0x00,\ -/* 96 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ -/* 104 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\ -/* 112 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00,\ -/* 120 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01,\ -/* 128 */ 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,\ -/* 136 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04,\ -/* 144 */ 0x04, 0x04,} - -/************** End of opcodes.h *********************************************/ -/************** Continuing where we left off in vdbe.h ***********************/ - -/* -** Prototypes for the VDBE interface. See comments on the implementation -** for a description of what each of these routines does. -*/ -SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*); -SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); -SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp); -SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1); -SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2); -SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3); -SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5); -SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); -SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr, int N); -SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); -SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); -SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); -SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,int,int,int,int,int,int); -SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); -SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); -#ifdef SQLITE_DEBUG -SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); -SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*); -#endif -SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); -SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); -SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); -SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); -SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); -SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int); -SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); -SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); -SQLITE_PRIVATE void sqlite3VdbeProgramDelete(sqlite3 *, SubProgram *, int); -SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8); -SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); -#ifndef SQLITE_OMIT_TRACE -SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); -#endif - -SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,char*,int); -SQLITE_PRIVATE void sqlite3VdbeDeleteUnpackedRecord(UnpackedRecord*); -SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); - - -#ifndef NDEBUG -SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); -# define VdbeComment(X) sqlite3VdbeComment X -SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); -# define VdbeNoopComment(X) sqlite3VdbeNoopComment X -#else -# define VdbeComment(X) -# define VdbeNoopComment(X) -#endif - -#endif - -/************** End of vdbe.h ************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include pager.h in the middle of sqliteInt.h *****************/ -/************** Begin file pager.h *******************************************/ -/* -** 2001 September 15 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the sqlite page cache -** subsystem. The page cache subsystem reads and writes a file a page -** at a time and provides a journal for rollback. -*/ - -#ifndef _PAGER_H_ -#define _PAGER_H_ - -/* -** Default maximum size for persistent journal files. A negative -** value means no limit. This value may be overridden using the -** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". -*/ -#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT - #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 -#endif - -/* -** The type used to represent a page number. The first page in a file -** is called page 1. 0 is used to represent "not a page". -*/ -typedef u32 Pgno; - -/* -** Each open file is managed by a separate instance of the "Pager" structure. -*/ -typedef struct Pager Pager; - -/* -** Handle type for pages. -*/ -typedef struct PgHdr DbPage; - -/* -** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is -** reserved for working around a windows/posix incompatibility). It is -** used in the journal to signify that the remainder of the journal file -** is devoted to storing a master journal name - there are no more pages to -** roll back. See comments for function writeMasterJournal() in pager.c -** for details. -*/ -#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) - -/* -** Allowed values for the flags parameter to sqlite3PagerOpen(). -** -** NOTE: These values must match the corresponding BTREE_ values in btree.h. -*/ -#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ -#define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */ - -/* -** Valid values for the second argument to sqlite3PagerLockingMode(). -*/ -#define PAGER_LOCKINGMODE_QUERY -1 -#define PAGER_LOCKINGMODE_NORMAL 0 -#define PAGER_LOCKINGMODE_EXCLUSIVE 1 - -/* -** Valid values for the second argument to sqlite3PagerJournalMode(). -*/ -#define PAGER_JOURNALMODE_QUERY -1 -#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ -#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ -#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ -#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ -#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ - -/* -** The remainder of this file contains the declarations of the functions -** that make up the Pager sub-system API. See source code comments for -** a detailed description of each routine. -*/ - -/* Open and close a Pager connection. */ -SQLITE_PRIVATE int sqlite3PagerOpen( - sqlite3_vfs*, - Pager **ppPager, - const char*, - int, - int, - int, - void(*)(DbPage*) -); -SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager); -SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); - -/* Functions used to configure a Pager object. */ -SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *); -SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u16*, int); -SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int); -SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); -SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int); -SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); -SQLITE_PRIVATE int sqlite3PagerJournalMode(Pager *, int); -SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); -SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); - -/* Functions used to obtain and release page references. */ -SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); -#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) -SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); -SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); -SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); - -/* Operations on page references. */ -SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); -SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); -SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); -SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); -SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); -SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); - -/* Functions used to manage pager transactions and savepoints. */ -SQLITE_PRIVATE int sqlite3PagerPagecount(Pager*, int*); -SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); -SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int); -SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager); -SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); -SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); -SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); -SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); -SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); - -/* Functions used to query pager state and configuration. */ -SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); -SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); -SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*); -SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*); -SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); -SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); -SQLITE_PRIVATE int sqlite3PagerNosync(Pager*); -SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); -SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); - -/* Functions used to truncate the database file. */ -SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); - -/* Functions to support testing and debugging. */ -#if !defined(NDEBUG) || defined(SQLITE_TEST) -SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); -SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); -#endif -#ifdef SQLITE_TEST -SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); -SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); - void disable_simulated_io_errors(void); - void enable_simulated_io_errors(void); -#else -# define disable_simulated_io_errors() -# define enable_simulated_io_errors() -#endif - -#endif /* _PAGER_H_ */ - -/************** End of pager.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include pcache.h in the middle of sqliteInt.h ****************/ -/************** Begin file pcache.h ******************************************/ -/* -** 2008 August 05 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** This header file defines the interface that the sqlite page cache -** subsystem. -*/ - -#ifndef _PCACHE_H_ - -typedef struct PgHdr PgHdr; -typedef struct PCache PCache; - -/* -** Every page in the cache is controlled by an instance of the following -** structure. -*/ -struct PgHdr { - void *pData; /* Content of this page */ - void *pExtra; /* Extra content */ - PgHdr *pDirty; /* Transient list of dirty pages */ - Pgno pgno; /* Page number for this page */ - Pager *pPager; /* The pager this page is part of */ -#ifdef SQLITE_CHECK_PAGES - u32 pageHash; /* Hash of page content */ -#endif - u16 flags; /* PGHDR flags defined below */ - - /********************************************************************** - ** Elements above are public. All that follows is private to pcache.c - ** and should not be accessed by other modules. - */ - i16 nRef; /* Number of users of this page */ - PCache *pCache; /* Cache that owns this page */ - - PgHdr *pDirtyNext; /* Next element in list of dirty pages */ - PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ -}; - -/* Bit values for PgHdr.flags */ -#define PGHDR_DIRTY 0x002 /* Page has changed */ -#define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before - ** writing this page to the database */ -#define PGHDR_NEED_READ 0x008 /* Content is unread */ -#define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */ -#define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */ - -/* Initialize and shutdown the page cache subsystem */ -SQLITE_PRIVATE int sqlite3PcacheInitialize(void); -SQLITE_PRIVATE void sqlite3PcacheShutdown(void); - -/* Page cache buffer management: -** These routines implement SQLITE_CONFIG_PAGECACHE. -*/ -SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); - -/* Create a new pager cache. -** Under memory stress, invoke xStress to try to make pages clean. -** Only clean and unpinned pages can be reclaimed. -*/ -SQLITE_PRIVATE void sqlite3PcacheOpen( - int szPage, /* Size of every page */ - int szExtra, /* Extra space associated with each page */ - int bPurgeable, /* True if pages are on backing store */ - int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ - void *pStress, /* Argument to xStress */ - PCache *pToInit /* Preallocated space for the PCache */ -); - -/* Modify the page-size after the cache has been created. */ -SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int); - -/* Return the size in bytes of a PCache object. Used to preallocate -** storage space. -*/ -SQLITE_PRIVATE int sqlite3PcacheSize(void); - -/* One release per successful fetch. Page is pinned until released. -** Reference counted. -*/ -SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**); -SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); - -SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ -SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ -SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ -SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ - -/* Change a page number. Used by incr-vacuum. */ -SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); - -/* Remove all pages with pgno>x. Reset the cache if x==0 */ -SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); - -/* Get a list of all dirty pages in the cache, sorted by page number */ -SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); - -/* Reset and close the cache object */ -SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); - -/* Clear flags from pages of the page cache */ -SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); - -/* Discard the contents of the cache */ -SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); - -/* Return the total number of outstanding page references */ -SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*); - -/* Increment the reference count of an existing page */ -SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); - -SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*); - -/* Return the total number of pages stored in the cache */ -SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); - -#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) -/* Iterate through all dirty pages currently stored in the cache. This -** interface is only available if SQLITE_CHECK_PAGES is defined when the -** library is built. -*/ -SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); -#endif - -/* Set and get the suggested cache-size for the specified pager-cache. -** -** If no global maximum is configured, then the system attempts to limit -** the total number of pages cached by purgeable pager-caches to the sum -** of the suggested cache-sizes. -*/ -SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); -#ifdef SQLITE_TEST -SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); -#endif - -#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT -/* Try to return memory used by the pcache module to the main memory heap */ -SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); -#endif - -#ifdef SQLITE_TEST -SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); -#endif - -SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); - -#endif /* _PCACHE_H_ */ - -/************** End of pcache.h **********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - -/************** Include os.h in the middle of sqliteInt.h ********************/ -/************** Begin file os.h **********************************************/ -/* -** 2001 September 16 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -****************************************************************************** -** -** This header file (together with is companion C source-code file -** "os.c") attempt to abstract the underlying operating system so that -** the SQLite library will work on both POSIX and windows systems. -** -** This header file is #include-ed by sqliteInt.h and thus ends up -** being included by every source file. -*/ -#ifndef _SQLITE_OS_H_ -#define _SQLITE_OS_H_ - -/* -** Figure out if we are dealing with Unix, Windows, or some other -** operating system. After the following block of preprocess macros, -** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER -** will defined to either 1 or 0. One of the four will be 1. The other -** three will be 0. -*/ -#if defined(SQLITE_OS_OTHER) -# if SQLITE_OS_OTHER==1 -# undef SQLITE_OS_UNIX -# define SQLITE_OS_UNIX 0 -# undef SQLITE_OS_WIN -# define SQLITE_OS_WIN 0 -# undef SQLITE_OS_OS2 -# define SQLITE_OS_OS2 0 -# else -# undef SQLITE_OS_OTHER -# endif -#endif -#if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) -# define SQLITE_OS_OTHER 0 -# ifndef SQLITE_OS_WIN -# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) -# define SQLITE_OS_WIN 1 -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 0 -# elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__) -# define SQLITE_OS_WIN 0 -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 1 -# else -# define SQLITE_OS_WIN 0 -# define SQLITE_OS_UNIX 1 -# define SQLITE_OS_OS2 0 -# endif -# else -# define SQLITE_OS_UNIX 0 -# define SQLITE_OS_OS2 0 -# endif -#else -# ifndef SQLITE_OS_WIN -# define SQLITE_OS_WIN 0 -# endif -#endif - -/* -** Determine if we are dealing with WindowsCE - which has a much -** reduced API. -*/ -#if defined(_WIN32_WCE) -# define SQLITE_OS_WINCE 1 -#else -# define SQLITE_OS_WINCE 0 -#endif - - -/* -** Define the maximum size of a temporary filename -*/ -#if SQLITE_OS_WIN -# include -# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) -#elif SQLITE_OS_OS2 -# if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY) -# include /* has to be included before os2.h for linking to work */ -# endif -# define INCL_DOSDATETIME -# define INCL_DOSFILEMGR -# define INCL_DOSERRORS -# define INCL_DOSMISC -# define INCL_DOSPROCESS -# define INCL_DOSMODULEMGR -# define INCL_DOSSEMAPHORES -# include -# include -# define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP) -#else -# define SQLITE_TEMPNAME_SIZE 200 -#endif - -/* If the SET_FULLSYNC macro is not defined above, then make it -** a no-op -*/ -#ifndef SET_FULLSYNC -# define SET_FULLSYNC(x,y) -#endif - -/* -** The default size of a disk sector -*/ -#ifndef SQLITE_DEFAULT_SECTOR_SIZE -# define SQLITE_DEFAULT_SECTOR_SIZE 512 -#endif - -/* -** Temporary files are named starting with this prefix followed by 16 random -** alphanumeric characters, and no file extension. They are stored in the -** OS's standard temporary file directory, and are deleted prior to exit. -** If sqlite is being embedded in another program, you may wish to change the -** prefix to reflect your program's name, so that if your program exits -** prematurely, old temporary files can be easily identified. This can be done -** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. -** -** 2006-10-31: The default prefix used to be "sqlite_". But then -** Mcafee started using SQLite in their anti-virus product and it -** started putting files with the "sqlite" name in the c:/temp folder. -** This annoyed many windows users. Those users would then do a -** Google search for "sqlite", find the telephone numbers of the -** developers and call to wake them up at night and complain. -** For this reason, the default name prefix is changed to be "sqlite" -** spelled backwards. So the temp files are still identified, but -** anybody smart enough to figure out the code is also likely smart -** enough to know that calling the developer will not help get rid -** of the file. -*/ -#ifndef SQLITE_TEMP_FILE_PREFIX -# define SQLITE_TEMP_FILE_PREFIX "etilqs_" -#endif - -/* -** The following values may be passed as the second argument to -** sqlite3OsLock(). The various locks exhibit the following semantics: -** -** SHARED: Any number of processes may hold a SHARED lock simultaneously. -** RESERVED: A single process may hold a RESERVED lock on a file at -** any time. Other processes may hold and obtain new SHARED locks. -** PENDING: A single process may hold a PENDING lock on a file at -** any one time. Existing SHARED locks may persist, but no new -** SHARED locks may be obtained by other processes. -** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. -** -** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a -** process that requests an EXCLUSIVE lock may actually obtain a PENDING -** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to -** sqlite3OsLock(). -*/ -#define NO_LOCK 0 -#define SHARED_LOCK 1 -#define RESERVED_LOCK 2 -#define PENDING_LOCK 3 -#define EXCLUSIVE_LOCK 4 - -/* -** File Locking Notes: (Mostly about windows but also some info for Unix) -** -** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because -** those functions are not available. So we use only LockFile() and -** UnlockFile(). -** -** LockFile() prevents not just writing but also reading by other processes. -** A SHARED_LOCK is obtained by locking a single randomly-chosen -** byte out of a specific range of bytes. The lock byte is obtained at -** random so two separate readers can probably access the file at the -** same time, unless they are unlucky and choose the same lock byte. -** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. -** There can only be one writer. A RESERVED_LOCK is obtained by locking -** a single byte of the file that is designated as the reserved lock byte. -** A PENDING_LOCK is obtained by locking a designated byte different from -** the RESERVED_LOCK byte. -** -** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, -** which means we can use reader/writer locks. When reader/writer locks -** are used, the lock is placed on the same range of bytes that is used -** for probabilistic locking in Win95/98/ME. Hence, the locking scheme -** will support two or more Win95 readers or two or more WinNT readers. -** But a single Win95 reader will lock out all WinNT readers and a single -** WinNT reader will lock out all other Win95 readers. -** -** The following #defines specify the range of bytes used for locking. -** SHARED_SIZE is the number of bytes available in the pool from which -** a random byte is selected for a shared lock. The pool of bytes for -** shared locks begins at SHARED_FIRST. -** -** The same locking strategy and -** byte ranges are used for Unix. This leaves open the possiblity of having -** clients on win95, winNT, and unix all talking to the same shared file -** and all locking correctly. To do so would require that samba (or whatever -** tool is being used for file sharing) implements locks correctly between -** windows and unix. I'm guessing that isn't likely to happen, but by -** using the same locking range we are at least open to the possibility. -** -** Locking in windows is manditory. For this reason, we cannot store -** actual data in the bytes used for locking. The pager never allocates -** the pages involved in locking therefore. SHARED_SIZE is selected so -** that all locks will fit on a single page even at the minimum page size. -** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE -** is set high so that we don't have to allocate an unused page except -** for very large databases. But one should test the page skipping logic -** by setting PENDING_BYTE low and running the entire regression suite. -** -** Changing the value of PENDING_BYTE results in a subtly incompatible -** file format. Depending on how it is changed, you might not notice -** the incompatibility right away, even running a full regression test. -** The default location of PENDING_BYTE is the first byte past the -** 1GB boundary. -** -*/ -#define PENDING_BYTE sqlite3PendingByte -#define RESERVED_BYTE (PENDING_BYTE+1) -#define SHARED_FIRST (PENDING_BYTE+2) -#define SHARED_SIZE 510 - -/* -** Wrapper around OS specific sqlite3_os_init() function. -*/ -SQLITE_PRIVATE int sqlite3OsInit(void); - -/* -** Functions for accessing sqlite3_file methods -*/ -SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*); -SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); -SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); -SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); -SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); -SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); -SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); -SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); -#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 -SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); -SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); - -/* -** Functions for accessing sqlite3_vfs methods -*/ -SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); -SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); -SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); -SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); -#ifndef SQLITE_OMIT_LOAD_EXTENSION -SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); -SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); -SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); -SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); -#endif /* SQLITE_OMIT_LOAD_EXTENSION */ -SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); -SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); -SQLITE_PRIVATE int sqlite3OsCurrentTime(sqlite3_vfs *, double*); - -/* -** Convenience functions for opening and closing files using -** sqlite3_malloc() to obtain space for the file-handle structure. -*/ -SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); -SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *); - -#endif /* _SQLITE_OS_H_ */ - -/************** End of os.h **************************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ -/************** Include mutex.h in the middle of sqliteInt.h *****************/ -/************** Begin file mutex.h *******************************************/ -/* -** 2007 August 28 -** -** The author disclaims copyright to this source code. In place of -** a legal notice, here is a blessing: -** -** May you do good and not evil. -** May you find forgiveness for yourself and forgive others. -** May you share freely, never taking more than you give. -** -************************************************************************* -** -** This file contains the common header for all mutex implementations. -** The sqliteInt.h header #includes this file so that it is available -** to all source files. We break it out in an effort to keep the code -** better organized. -** -** NOTE: source files should *not* #include this header file directly. -** Source files should #include the sqliteInt.h file and let that file -** include this one indirectly. -*/ - - -/* -** Figure out what version of the code to use. The choices are -** -** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The -** mutexes implemention cannot be overridden -** at start-time. -** -** SQLITE_MUTEX_NOOP For single-threaded applications. No -** mutual exclusion is provided. But this -** implementation can be overridden at -** start-time. -** -** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. -** -** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. -** -** SQLITE_MUTEX_OS2 For multi-threaded applications on OS/2. -*/ -#if !SQLITE_THREADSAFE -# define SQLITE_MUTEX_OMIT -#endif -#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) -# if SQLITE_OS_UNIX -# define SQLITE_MUTEX_PTHREADS -# elif SQLITE_OS_WIN -# define SQLITE_MUTEX_W32 -# elif SQLITE_OS_OS2 -# define SQLITE_MUTEX_OS2 -# else -# define SQLITE_MUTEX_NOOP -# endif -#endif - -#ifdef SQLITE_MUTEX_OMIT -/* -** If this is a no-op implementation, implement everything as macros. -*/ -#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) -#define sqlite3_mutex_free(X) -#define sqlite3_mutex_enter(X) -#define sqlite3_mutex_try(X) SQLITE_OK -#define sqlite3_mutex_leave(X) -#define sqlite3_mutex_held(X) 1 -#define sqlite3_mutex_notheld(X) 1 -#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) -#define sqlite3MutexInit() SQLITE_OK -#define sqlite3MutexEnd() -#endif /* defined(SQLITE_MUTEX_OMIT) */ - -/************** End of mutex.h ***********************************************/ -/************** Continuing where we left off in sqliteInt.h ******************/ - - -/* -** Each database file to be accessed by the system is an instance -** of the following structure. There are normally two of these structures -** in the sqlite.aDb[] array. aDb[0] is the main database file and -** aDb[1] is the database file used to hold temporary tables. Additional -** databases may be attached. -*/ -struct Db { - char *zName; /* Name of this database */ - Btree *pBt; /* The B*Tree structure for this database file */ - u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ - u8 safety_level; /* How aggressive at syncing data to disk */ - Schema *pSchema; /* Pointer to database schema (possibly shared) */ -}; - -/* -** An instance of the following structure stores a database schema. -** -** If there are no virtual tables configured in this schema, the -** Schema.db variable is set to NULL. After the first virtual table -** has been added, it is set to point to the database connection -** used to create the connection. Once a virtual table has been -** added to the Schema structure and the Schema.db variable populated, -** only that database connection may use the Schema to prepare -** statements. -*/ -struct Schema { - int schema_cookie; /* Database schema version number for this file */ - Hash tblHash; /* All tables indexed by name */ - Hash idxHash; /* All (named) indices indexed by name */ - Hash trigHash; /* All triggers indexed by name */ - Hash fkeyHash; /* All foreign keys by referenced table name */ - Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ - u8 file_format; /* Schema format version for this file */ - u8 enc; /* Text encoding used by this database */ - u16 flags; /* Flags associated with this schema */ - int cache_size; /* Number of pages to use in the cache */ -#ifndef SQLITE_OMIT_VIRTUALTABLE - sqlite3 *db; /* "Owner" connection. See comment above */ -#endif -}; - -/* -** These macros can be used to test, set, or clear bits in the -** Db.pSchema->flags field. -*/ -#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) -#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) -#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) -#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P) - -/* -** Allowed values for the DB.pSchema->flags field. -** -** The DB_SchemaLoaded flag is set after the database schema has been -** read into internal hash tables. -** -** DB_UnresetViews means that one or more views have column names that -** have been filled out. If the schema changes, these column names might -** changes and so the view will need to be reset. -*/ -#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ -#define DB_UnresetViews 0x0002 /* Some views have defined column names */ -#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ - -/* -** The number of different kinds of things that can be limited -** using the sqlite3_limit() interface. -*/ -#define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1) - -/* -** Lookaside malloc is a set of fixed-size buffers that can be used -** to satisfy small transient memory allocation requests for objects -** associated with a particular database connection. The use of -** lookaside malloc provides a significant performance enhancement -** (approx 10%) by avoiding numerous malloc/free requests while parsing -** SQL statements. -** -** The Lookaside structure holds configuration information about the -** lookaside malloc subsystem. Each available memory allocation in -** the lookaside subsystem is stored on a linked list of LookasideSlot -** objects. -** -** Lookaside allocations are only allowed for objects that are associated -** with a particular database connection. Hence, schema information cannot -** be stored in lookaside because in shared cache mode the schema information -** is shared by multiple database connections. Therefore, while parsing -** schema information, the Lookaside.bEnabled flag is cleared so that -** lookaside allocations are not used to construct the schema objects. -*/ -struct Lookaside { - u16 sz; /* Size of each buffer in bytes */ - u8 bEnabled; /* False to disable new lookaside allocations */ - u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ - int nOut; /* Number of buffers currently checked out */ - int mxOut; /* Highwater mark for nOut */ - LookasideSlot *pFree; /* List of available buffers */ - void *pStart; /* First byte of available memory space */ - void *pEnd; /* First byte past end of available space */ -}; -struct LookasideSlot { - LookasideSlot *pNext; /* Next buffer in the list of free buffers */ -}; - -/* -** A hash table for function definitions. -** -** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. -** Collisions are on the FuncDef.pHash chain. -*/ -struct FuncDefHash { - FuncDef *a[23]; /* Hash table for functions */ -}; - -/* -** Each database connection is an instance of the following structure. -** -** The sqlite.lastRowid records the last insert rowid generated by an -** insert statement. Inserts on views do not affect its value. Each -** trigger has its own context, so that lastRowid can be updated inside -** triggers as usual. The previous value will be restored once the trigger -** exits. Upon entering a before or instead of trigger, lastRowid is no -** longer (since after version 2.8.12) reset to -1. -** -** The sqlite.nChange does not count changes within triggers and keeps no -** context. It is reset at start of sqlite3_exec. -** The sqlite.lsChange represents the number of changes made by the last -** insert, update, or delete statement. It remains constant throughout the -** length of a statement and is then updated by OP_SetCounts. It keeps a -** context stack just like lastRowid so that the count of changes -** within a trigger is not seen outside the trigger. Changes to views do not -** affect the value of lsChange. -** The sqlite.csChange keeps track of the number of current changes (since -** the last statement) and is used to update sqlite_lsChange. -** -** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16 -** store the most recent error code and, if applicable, string. The -** internal function sqlite3Error() is used to set these variables -** consistently. -*/ -struct sqlite3 { - sqlite3_vfs *pVfs; /* OS Interface */ - int nDb; /* Number of backends currently in use */ - Db *aDb; /* All backends */ - int flags; /* Miscellaneous flags. See below */ - int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ - int errCode; /* Most recent error code (SQLITE_*) */ - int errMask; /* & result codes with this before returning */ - u8 autoCommit; /* The auto-commit flag. */ - u8 temp_store; /* 1: file 2: memory 0: default */ - u8 mallocFailed; /* True if we have seen a malloc failure */ - u8 dfltLockMode; /* Default locking-mode for attached dbs */ - u8 dfltJournalMode; /* Default journal mode for attached dbs */ - signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ - u8 suppressErr; /* Do not issue error messages if true */ - int nextPagesize; /* Pagesize after VACUUM if >0 */ - int nTable; /* Number of tables in the database */ - CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ - i64 lastRowid; /* ROWID of most recent insert (see above) */ - u32 magic; /* Magic number for detect library misuse */ - int nChange; /* Value returned by sqlite3_changes() */ - int nTotalChange; /* Value returned by sqlite3_total_changes() */ - sqlite3_mutex *mutex; /* Connection mutex */ - int aLimit[SQLITE_N_LIMIT]; /* Limits */ - struct sqlite3InitInfo { /* Information used during initialization */ - int iDb; /* When back is being initialized */ - int newTnum; /* Rootpage of table being initialized */ - u8 busy; /* TRUE if currently initializing */ - u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */ - } init; - int nExtension; /* Number of loaded extensions */ - void **aExtension; /* Array of shared library handles */ - struct Vdbe *pVdbe; /* List of active virtual machines */ - int activeVdbeCnt; /* Number of VDBEs currently executing */ - int writeVdbeCnt; /* Number of active VDBEs that are writing */ - void (*xTrace)(void*,const char*); /* Trace function */ - void *pTraceArg; /* Argument to the trace function */ - void (*xProfile)(void*,const char*,u64); /* Profiling function */ - void *pProfileArg; /* Argument to profile function */ - void *pCommitArg; /* Argument to xCommitCallback() */ - int (*xCommitCallback)(void*); /* Invoked at every commit. */ - void *pRollbackArg; /* Argument to xRollbackCallback() */ - void (*xRollbackCallback)(void*); /* Invoked at every commit. */ - void *pUpdateArg; - void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); - void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); - void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); - void *pCollNeededArg; - sqlite3_value *pErr; /* Most recent error message */ - char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ - char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ - union { - volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ - double notUsed1; /* Spacer */ - } u1; - Lookaside lookaside; /* Lookaside malloc configuration */ -#ifndef SQLITE_OMIT_AUTHORIZATION - int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); - /* Access authorization function */ - void *pAuthArg; /* 1st argument to the access auth function */ -#endif -#ifndef SQLITE_OMIT_PROGRESS_CALLBACK - int (*xProgress)(void *); /* The progress callback */ - void *pProgressArg; /* Argument to the progress callback */ - int nProgressOps; /* Number of opcodes for progress callback */ -#endif -#ifndef SQLITE_OMIT_VIRTUALTABLE - Hash aModule; /* populated by sqlite3_create_module() */ - Table *pVTab; /* vtab with active Connect/Create method */ - VTable **aVTrans; /* Virtual tables with open transactions */ - int nVTrans; /* Allocated size of aVTrans */ - VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ -#endif - FuncDefHash aFunc; /* Hash table of connection functions */ - Hash aCollSeq; /* All collating sequences */ - BusyHandler busyHandler; /* Busy callback */ - int busyTimeout; /* Busy handler timeout, in msec */ - Db aDbStatic[2]; /* Static space for the 2 default backends */ - Savepoint *pSavepoint; /* List of active savepoints */ - int nSavepoint; /* Number of non-transaction savepoints */ - int nStatement; /* Number of nested statement-transactions */ - u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ - i64 nDeferredCons; /* Net deferred constraints this transaction. */ - -#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY - /* The following variables are all protected by the STATIC_MASTER - ** mutex, not by sqlite3.mutex. They are used by code in notify.c. - ** - ** When X.pUnlockConnection==Y, that means that X is waiting for Y to - ** unlock so that it can proceed. - ** - ** When X.pBlockingConnection==Y, that means that something that X tried - ** tried to do recently failed with an SQLITE_LOCKED error due to locks - ** held by Y. - */ - sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ - sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ - void *pUnlockArg; /* Argument to xUnlockNotify */ - void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ - sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ -#endif -}; - -/* -** A macro to discover the encoding of a database. -*/ -#define ENC(db) ((db)->aDb[0].pSchema->enc) - -/* -** Possible values for the sqlite3.flags. -*/ -#define SQLITE_VdbeTrace 0x00000100 /* True to trace VDBE execution */ -#define SQLITE_InternChanges 0x00000200 /* Uncommitted Hash table changes */ -#define SQLITE_FullColNames 0x00000400 /* Show full column names on SELECT */ -#define SQLITE_ShortColNames 0x00000800 /* Show short columns names */ -#define SQLITE_CountRows 0x00001000 /* Count rows changed by INSERT, */ - /* DELETE, or UPDATE and return */ - /* the count using a callback. */ -#define SQLITE_NullCallback 0x00002000 /* Invoke the callback once if the */ - /* result set is empty */ -#define SQLITE_SqlTrace 0x00004000 /* Debug print SQL as it executes */ -#define SQLITE_VdbeListing 0x00008000 /* Debug listings of VDBE programs */ -#define SQLITE_WriteSchema 0x00010000 /* OK to update SQLITE_MASTER */ -#define SQLITE_NoReadlock 0x00020000 /* Readlocks are omitted when - ** accessing read-only databases */ -#define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */ -#define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */ -#define SQLITE_LegacyFileFmt 0x00100000 /* Create new databases in format 1 */ -#define SQLITE_FullFSync 0x00200000 /* Use full fsync on the backend */ -#define SQLITE_LoadExtension 0x00400000 /* Enable load_extension */ -#define SQLITE_RecoveryMode 0x00800000 /* Ignore schema errors */ -#define SQLITE_ReverseOrder 0x01000000 /* Reverse unordered SELECTs */ -#define SQLITE_RecTriggers 0x02000000 /* Enable recursive triggers */ -#define SQLITE_ForeignKeys 0x04000000 /* Enforce foreign key constraints */ - -/* -** Bits of the sqlite3.flags field that are used by the -** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface. -** These must be the low-order bits of the flags field. -*/ -#define SQLITE_QueryFlattener 0x01 /* Disable query flattening */ -#define SQLITE_ColumnCache 0x02 /* Disable the column cache */ -#define SQLITE_IndexSort 0x04 /* Disable indexes for sorting */ -#define SQLITE_IndexSearch 0x08 /* Disable indexes for searching */ -#define SQLITE_IndexCover 0x10 /* Disable index covering table */ -#define SQLITE_OptMask 0x1f /* Mask of all disablable opts */ - -/* -** Possible values for the sqlite.magic field. -** The numbers are obtained at random and have no special meaning, other -** than being distinct from one another. -*/ -#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ -#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ -#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ -#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ -#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ - -/* -** Each SQL function is defined by an instance of the following -** structure. A pointer to this structure is stored in the sqlite.aFunc -** hash table. When multiple functions have the same name, the hash table -** points to a linked list of these structures. -*/ -struct FuncDef { - i16 nArg; /* Number of arguments. -1 means unlimited */ - u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ - u8 flags; /* Some combination of SQLITE_FUNC_* */ - void *pUserData; /* User data parameter */ - FuncDef *pNext; /* Next function with same name */ - void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ - void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ - void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */ - char *zName; /* SQL name of the function. */ - FuncDef *pHash; /* Next with a different name but the same hash */ -}; - -/* -** Possible values for FuncDef.flags -*/ -#define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ -#define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ -#define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */ -#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */ -#define SQLITE_FUNC_PRIVATE 0x10 /* Allowed for internal use only */ -#define SQLITE_FUNC_COUNT 0x20 /* Built-in count(*) aggregate */ -#define SQLITE_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */ - -/* -** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are -** used to create the initializers for the FuncDef structures. -** -** FUNCTION(zName, nArg, iArg, bNC, xFunc) -** Used to create a scalar function definition of a function zName -** implemented by C function xFunc that accepts nArg arguments. The -** value passed as iArg is cast to a (void*) and made available -** as the user-data (sqlite3_user_data()) for the function. If -** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. -** -** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) -** Used to create an aggregate function definition implemented by -** the C functions xStep and xFinal. The first four parameters -** are interpreted in the same way as the first 4 parameters to -** FUNCTION(). -** -** LIKEFUNC(zName, nArg, pArg, flags) -** Used to create a scalar function definition of a function zName -** that accepts nArg arguments and is implemented by a call to C -** function likeFunc. Argument pArg is cast to a (void *) and made -** available as the function user-data (sqlite3_user_data()). The -** FuncDef.flags variable is set to the value passed as the flags -** parameter. -*/ -#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ - SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0} -#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ - {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ - pArg, 0, xFunc, 0, 0, #zName, 0} -#define LIKEFUNC(zName, nArg, arg, flags) \ - {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0} -#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ - {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \ - SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0} - -/* -** All current savepoints are stored in a linked list starting at -** sqlite3.pSavepoint. The first element in the list is the most recently -** opened savepoint. Savepoints are added to the list by the vdbe -** OP_Savepoint instruction. -*/ -struct Savepoint { - char *zName; /* Savepoint name (nul-terminated) */ - i64 nDeferredCons; /* Number of deferred fk violations */ - Savepoint *pNext; /* Parent savepoint (if any) */ -}; - -/* -** The following are used as the second parameter to sqlite3Savepoint(), -** and as the P1 argument to the OP_Savepoint instruction. -*/ -#define SAVEPOINT_BEGIN 0 -#define SAVEPOINT_RELEASE 1 -#define SAVEPOINT_ROLLBACK 2 - - -/* -** Each SQLite module (virtual table definition) is defined by an -** instance of the following structure, stored in the sqlite3.aModule -** hash table. -*/ -struct Module { - const sqlite3_module *pModule; /* Callback pointers */ - const char *zName; /* Name passed to create_module() */ - void *pAux; /* pAux passed to create_module() */ - void (*xDestroy)(void *); /* Module destructor function */ -}; - -/* -** information about each column of an SQL table is held in an instance -** of this structure. -*/ -struct Column { - char *zName; /* Name of this column */ - Expr *pDflt; /* Default value of this column */ - char *zDflt; /* Original text of the default value */ - char *zType; /* Data type for this column */ - char *zColl; /* Collating sequence. If NULL, use the default */ - u8 notNull; /* True if there is a NOT NULL constraint */ - u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ - char affinity; /* One of the SQLITE_AFF_... values */ -#ifndef SQLITE_OMIT_VIRTUALTABLE - u8 isHidden; /* True if this column is 'hidden' */ -#endif -}; - -/* -** A "Collating Sequence" is defined by an instance of the following -** structure. Conceptually, a collating sequence consists of a name and -** a comparison routine that defines the order of that sequence. -** -** There may two separate implementations of the collation function, one -** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that -** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine -** native byte order. When a collation sequence is invoked, SQLite selects -** the version that will require the least expensive encoding -** translations, if any. -** -** The CollSeq.pUser member variable is an extra parameter that passed in -** as the first argument to the UTF-8 comparison function, xCmp. -** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function, -** xCmp16. -** -** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the -** collating sequence is undefined. Indices built on an undefined -** collating sequence may not be read or written. -*/ -struct CollSeq { - char *zName; /* Name of the collating sequence, UTF-8 encoded */ - u8 enc; /* Text encoding handled by xCmp() */ - u8 type; /* One of the SQLITE_COLL_... values below */ - void *pUser; /* First argument to xCmp() */ - int (*xCmp)(void*,int, const void*, int, const void*); - void (*xDel)(void*); /* Destructor for pUser */ -}; - -/* -** Allowed values of CollSeq.type: -*/ -#define SQLITE_COLL_BINARY 1 /* The default memcmp() collating sequence */ -#define SQLITE_COLL_NOCASE 2 /* The built-in NOCASE collating sequence */ -#define SQLITE_COLL_REVERSE 3 /* The built-in REVERSE collating sequence */ -#define SQLITE_COLL_USER 0 /* Any other user-defined collating sequence */ - -/* -** A sort order can be either ASC or DESC. -*/ -#define SQLITE_SO_ASC 0 /* Sort in ascending order */ -#define SQLITE_SO_DESC 1 /* Sort in ascending order */ - -/* -** Column affinity types. -** -** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and -** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve -** the speed a little by numbering the values consecutively. -** -** But rather than start with 0 or 1, we begin with 'a'. That way, -** when multiple affinity types are concatenated into a string and -** used as the P4 operand, they will be more readable. -** -** Note also that the numeric types are grouped together so that testing -** for a numeric type is a single comparison. -*/ -#define SQLITE_AFF_TEXT 'a' -#define SQLITE_AFF_NONE 'b' -#define SQLITE_AFF_NUMERIC 'c' -#define SQLITE_AFF_INTEGER 'd' -#define SQLITE_AFF_REAL 'e' - -#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) - -/* -** The SQLITE_AFF_MASK values masks off the significant bits of an -** affinity value. -*/ -#define SQLITE_AFF_MASK 0x67 - -/* -** Additional bit values that can be ORed with an affinity without -** changing the affinity. -*/ -#define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */ -#define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */ -#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ - -/* -** An object of this type is created for each virtual table present in -** the database schema. -** -** If the database schema is shared, then there is one instance of this -** structure for each database connection (sqlite3*) that uses the shared -** schema. This is because each database connection requires its own unique -** instance of the sqlite3_vtab* handle used to access the virtual table -** implementation. sqlite3_vtab* handles can not be shared between -** database connections, even when the rest of the in-memory database -** schema is shared, as the implementation often stores the database -** connection handle passed to it via the xConnect() or xCreate() method -** during initialization internally. This database connection handle may -** then used by the virtual table implementation to access real tables -** within the database. So that they appear as part of the callers -** transaction, these accesses need to be made via the same database -** connection as that used to execute SQL operations on the virtual table. -** -** All VTable objects that correspond to a single table in a shared -** database schema are initially stored in a linked-list pointed to by -** the Table.pVTable member variable of the corresponding Table object. -** When an sqlite3_prepare() operation is required to access the virtual -** table, it searches the list for the VTable that corresponds to the -** database connection doing the preparing so as to use the correct -** sqlite3_vtab* handle in the compiled query. -** -** When an in-memory Table object is deleted (for example when the -** schema is being reloaded for some reason), the VTable objects are not -** deleted and the sqlite3_vtab* handles are not xDisconnect()ed -** immediately. Instead, they are moved from the Table.pVTable list to -** another linked list headed by the sqlite3.pDisconnect member of the -** corresponding sqlite3 structure. They are then deleted/xDisconnected -** next time a statement is prepared using said sqlite3*. This is done -** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. -** Refer to comments above function sqlite3VtabUnlockList() for an -** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect -** list without holding the corresponding sqlite3.mutex mutex. -** -** The memory for objects of this type is always allocated by -** sqlite3DbMalloc(), using the connection handle stored in VTable.db as -** the first argument. -*/ -struct VTable { - sqlite3 *db; /* Database connection associated with this table */ - Module *pMod; /* Pointer to module implementation */ - sqlite3_vtab *pVtab; /* Pointer to vtab instance */ - int nRef; /* Number of pointers to this structure */ - VTable *pNext; /* Next in linked list (see above) */ -}; - -/* -** Each SQL table is represented in memory by an instance of the -** following structure. -** -** Table.zName is the name of the table. The case of the original -** CREATE TABLE statement is stored, but case is not significant for -** comparisons. -** -** Table.nCol is the number of columns in this table. Table.aCol is a -** pointer to an array of Column structures, one for each column. -** -** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of -** the column that is that key. Otherwise Table.iPKey is negative. Note -** that the datatype of the PRIMARY KEY must be INTEGER for this field to -** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of -** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid -** is generated for each row of the table. TF_HasPrimaryKey is set if -** the table has any PRIMARY KEY, INTEGER or otherwise. -** -** Table.tnum is the page number for the root BTree page of the table in the -** database file. If Table.iDb is the index of the database table backend -** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that -** holds temporary tables and indices. If TF_Ephemeral is set -** then the table is stored in a file that is automatically deleted -** when the VDBE cursor to the table is closed. In this case Table.tnum -** refers VDBE cursor number that holds the table open, not to the root -** page number. Transient tables are used to hold the results of a -** sub-query that appears instead of a real table name in the FROM clause -** of a SELECT statement. -*/ -struct Table { - sqlite3 *dbMem; /* DB connection used for lookaside allocations. */ - char *zName; /* Name of the table or view */ - int iPKey; /* If not negative, use aCol[iPKey] as the primary key */ - int nCol; /* Number of columns in this table */ - Column *aCol; /* Information about each column */ - Index *pIndex; /* List of SQL indexes on this table. */ - int tnum; /* Root BTree node for this table (see note above) */ - Select *pSelect; /* NULL for tables. Points to definition if a view. */ - u16 nRef; /* Number of pointers to this Table */ - u8 tabFlags; /* Mask of TF_* values */ - u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ - FKey *pFKey; /* Linked list of all foreign keys in this table */ - char *zColAff; /* String defining the affinity of each column */ -#ifndef SQLITE_OMIT_CHECK - Expr *pCheck; /* The AND of all CHECK constraints */ -#endif -#ifndef SQLITE_OMIT_ALTERTABLE - int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ -#endif -#ifndef SQLITE_OMIT_VIRTUALTABLE - VTable *pVTable; /* List of VTable objects. */ - int nModuleArg; /* Number of arguments to the module */ - char **azModuleArg; /* Text of all module args. [0] is module name */ -#endif - Trigger *pTrigger; /* List of triggers stored in pSchema */ - Schema *pSchema; /* Schema that contains this table */ - Table *pNextZombie; /* Next on the Parse.pZombieTab list */ -}; - -/* -** Allowed values for Tabe.tabFlags. -*/ -#define TF_Readonly 0x01 /* Read-only system table */ -#define TF_Ephemeral 0x02 /* An ephemeral table */ -#define TF_HasPrimaryKey 0x04 /* Table has a primary key */ -#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */ -#define TF_Virtual 0x10 /* Is a virtual table */ -#define TF_NeedMetadata 0x20 /* aCol[].zType and aCol[].pColl missing */ - - - -/* -** Test to see whether or not a table is a virtual table. This is -** done as a macro so that it will be optimized out when virtual -** table support is omitted from the build. -*/ -#ifndef SQLITE_OMIT_VIRTUALTABLE -# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) -# define IsHiddenColumn(X) ((X)->isHidden) -#else -# define IsVirtual(X) 0 -# define IsHiddenColumn(X) 0 -#endif - -/* -** Each foreign key constraint is an instance of the following structure. -** -** A foreign key is associated with two tables. The "from" table is -** the table that contains the REFERENCES clause that creates the foreign -** key. The "to" table is the table that is named in the REFERENCES clause. -** Consider this example: -** -** CREATE TABLE ex1( -** a INTEGER PRIMARY KEY, -** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) -** ); -** -** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". -** -** Each REFERENCES clause generates an instance of the following structure -** which is attached to the from-table. The to-table need not exist when -** the from-table is created. The existence of the to-table is not checked. -*/ -struct FKey { - Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ - FKey *pNextFrom; /* Next foreign key in pFrom */ - char *zTo; /* Name of table that the key points to (aka: Parent) */ - FKey *pNextTo; /* Next foreign key on table named zTo */ - FKey *pPrevTo; /* Previous foreign key on table named zTo */ - int nCol; /* Number of columns in this key */ - /* EV: R-30323-21917 */ - u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ - u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ - Trigger *apTrigger[2]; /* Triggers for aAction[] actions */ - struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ - int iFrom; /* Index of column in pFrom */ - char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ - } aCol[1]; /* One entry for each of nCol column s */ -}; - -/* -** SQLite supports many different ways to resolve a constraint -** error. ROLLBACK processing means that a constraint violation -** causes the operation in process to fail and for the current transaction -** to be rolled back. ABORT processing means the operation in process -** fails and any prior changes from that one operation are backed out, -** but the transaction is not rolled back. FAIL processing means that -** the operation in progress stops and returns an error code. But prior -** changes due to the same operation are not backed out and no rollback -** occurs. IGNORE means that the particular row that caused the constraint -** error is not inserted or updated. Processing continues and no error -** is returned. REPLACE means that preexisting database rows that caused -** a UNIQUE constraint violation are removed so that the new insert or -** update can proceed. Processing continues and no error is reported. -** -** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. -** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the -** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign -** key is set to NULL. CASCADE means that a DELETE or UPDATE of the -** referenced table row is propagated into the row that holds the -** foreign key. -** -** The following symbolic values are used to record which type -** of action to take. -*/ -#define OE_None 0 /* There is no constraint to check */ -#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ -#define OE_Abort 2 /* Back out changes but do no rollback transaction */ -#define OE_Fail 3 /* Stop the operation but leave all prior changes */ -#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ -#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ - -#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ -#define OE_SetNull 7 /* Set the foreign key value to NULL */ -#define OE_SetDflt 8 /* Set the foreign key value to its default */ -#define OE_Cascade 9 /* Cascade the changes */ - -#define OE_Default 99 /* Do whatever the default action is */ - - -/* -** An instance of the following structure is passed as the first -** argument to sqlite3VdbeKeyCompare and is used to control the -** comparison of the two index keys. -*/ -struct KeyInfo { - sqlite3 *db; /* The database connection */ - u8 enc; /* Text encoding - one of the TEXT_Utf* values */ - u16 nField; /* Number of entries in aColl[] */ - u8 *aSortOrder; /* If defined an aSortOrder[i] is true, sort DESC */ - CollSeq *aColl[1]; /* Collating sequence for each term of the key */ -}; - -/* -** An instance of the following structure holds information about a -** single index record that has already been parsed out into individual -** values. -** -** A record is an object that contains one or more fields of data. -** Records are used to store the content of a table row and to store -** the key of an index. A blob encoding of a record is created by -** the OP_MakeRecord opcode of the VDBE and is disassembled by the -** OP_Column opcode. -** -** This structure holds a record that has already been disassembled -** into its constituent fields. -*/ -struct UnpackedRecord { - KeyInfo *pKeyInfo; /* Collation and sort-order information */ - u16 nField; /* Number of entries in apMem[] */ - u16 flags; /* Boolean settings. UNPACKED_... below */ - i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */ - Mem *aMem; /* Values */ -}; - -/* -** Allowed values of UnpackedRecord.flags -*/ -#define UNPACKED_NEED_FREE 0x0001 /* Memory is from sqlite3Malloc() */ -#define UNPACKED_NEED_DESTROY 0x0002 /* apMem[]s should all be destroyed */ -#define UNPACKED_IGNORE_ROWID 0x0004 /* Ignore trailing rowid on key1 */ -#define UNPACKED_INCRKEY 0x0008 /* Make this key an epsilon larger */ -#define UNPACKED_PREFIX_MATCH 0x0010 /* A prefix match is considered OK */ -#define UNPACKED_PREFIX_SEARCH 0x0020 /* A prefix match is considered OK */ - -/* -** Each SQL index is represented in memory by an -** instance of the following structure. -** -** The columns of the table that are to be indexed are described -** by the aiColumn[] field of this structure. For example, suppose -** we have the following table and index: -** -** CREATE TABLE Ex1(c1 int, c2 int, c3 text); -** CREATE INDEX Ex2 ON Ex1(c3,c1); -** -** In the Table structure describing Ex1, nCol==3 because there are -** three columns in the table. In the Index structure describing -** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. -** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the -** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. -** The second column to be indexed (c1) has an index of 0 in -** Ex1.aCol[], hence Ex2.aiColumn[1]==0. -** -** The Index.onError field determines whether or not the indexed columns -** must be unique and what to do if they are not. When Index.onError=OE_None, -** it means this is not a unique index. Otherwise it is a unique index -** and the value of Index.onError indicate the which conflict resolution -** algorithm to employ whenever an attempt is made to insert a non-unique -** element. -*/ -struct Index { - char *zName; /* Name of this index */ - int nColumn; /* Number of columns in the table used by this index */ - int *aiColumn; /* Which columns are used by this index. 1st is 0 */ - unsigned *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */ - Table *pTable; /* The SQL table being indexed */ - int tnum; /* Page containing root of this index in database file */ - u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ - u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ - char *zColAff; /* String defining the affinity of each column */ - Index *pNext; /* The next index associated with the same table */ - Schema *pSchema; /* Schema containing this index */ - u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */ - char **azColl; /* Array of collation sequence names for index */ - IndexSample *aSample; /* Array of SQLITE_INDEX_SAMPLES samples */ -}; - -/* -** Each sample stored in the sqlite_stat2 table is represented in memory -** using a structure of this type. -*/ -struct IndexSample { - union { - char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */ - double r; /* Value if eType is SQLITE_FLOAT or SQLITE_INTEGER */ - } u; - u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */ - u8 nByte; /* Size in byte of text or blob. */ -}; - -/* -** Each token coming out of the lexer is an instance of -** this structure. Tokens are also used as part of an expression. -** -** Note if Token.z==0 then Token.dyn and Token.n are undefined and -** may contain random values. Do not make any assumptions about Token.dyn -** and Token.n when Token.z==0. -*/ -struct Token { - const char *z; /* Text of the token. Not NULL-terminated! */ - unsigned int n; /* Number of characters in this token */ -}; - -/* -** An instance of this structure contains information needed to generate -** code for a SELECT that contains aggregate functions. -** -** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a -** pointer to this structure. The Expr.iColumn field is the index in -** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate -** code for that node. -** -** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the -** original Select structure that describes the SELECT statement. These -** fields do not need to be freed when deallocating the AggInfo structure. -*/ -struct AggInfo { - u8 directMode; /* Direct rendering mode means take data directly - ** from source tables rather than from accumulators */ - u8 useSortingIdx; /* In direct mode, reference the sorting index rather - ** than the source table */ - int sortingIdx; /* Cursor number of the sorting index */ - ExprList *pGroupBy; /* The group by clause */ - int nSortingColumn; /* Number of columns in the sorting index */ - struct AggInfo_col { /* For each column used in source tables */ - Table *pTab; /* Source table */ - int iTable; /* Cursor number of the source table */ - int iColumn; /* Column number within the source table */ - int iSorterColumn; /* Column number in the sorting index */ - int iMem; /* Memory location that acts as accumulator */ - Expr *pExpr; /* The original expression */ - } *aCol; - int nColumn; /* Number of used entries in aCol[] */ - int nColumnAlloc; /* Number of slots allocated for aCol[] */ - int nAccumulator; /* Number of columns that show through to the output. - ** Additional columns are used only as parameters to - ** aggregate functions */ - struct AggInfo_func { /* For each aggregate function */ - Expr *pExpr; /* Expression encoding the function */ - FuncDef *pFunc; /* The aggregate function implementation */ - int iMem; /* Memory location that acts as accumulator */ - int iDistinct; /* Ephemeral table used to enforce DISTINCT */ - } *aFunc; - int nFunc; /* Number of entries in aFunc[] */ - int nFuncAlloc; /* Number of slots allocated for aFunc[] */ -}; - -/* -** The datatype ynVar is a signed integer, either 16-bit or 32-bit. -** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater -** than 32767 we have to make it 32-bit. 16-bit is preferred because -** it uses less memory in the Expr object, which is a big memory user -** in systems with lots of prepared statements. And few applications -** need more than about 10 or 20 variables. But some extreme users want -** to have prepared statements with over 32767 variables, and for them -** the option is available (at compile-time). -*/ -#if SQLITE_MAX_VARIABLE_NUMBER<=32767 -typedef i16 ynVar; -#else -typedef int ynVar; -#endif - -/* -** Each node of an expression in the parse tree is an instance -** of this structure. -** -** Expr.op is the opcode. The integer parser token codes are reused -** as opcodes here. For example, the parser defines TK_GE to be an integer -** code representing the ">=" operator. This same integer code is reused -** to represent the greater-than-or-equal-to operator in the expression -** tree. -** -** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, -** or TK_STRING), then Expr.token contains the text of the SQL literal. If -** the expression is a variable (TK_VARIABLE), then Expr.token contains the -** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), -** then Expr.token contains the name of the function. -** -** Expr.pRight and Expr.pLeft are the left and right subexpressions of a -** binary operator. Either or both may be NULL. -** -** Expr.x.pList is a list of arguments if the expression is an SQL function, -** a CASE expression or an IN expression of the form " IN (, ...)". -** Expr.x.pSelect is used if the expression is a sub-select or an expression of -** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the -** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is -** valid. -** -** An expression of the form ID or ID.ID refers to a column in a table. -** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is -** the integer cursor number of a VDBE cursor pointing to that table and -** Expr.iColumn is the column number for the specific column. If the -** expression is used as a result in an aggregate SELECT, then the -** value is also stored in the Expr.iAgg column in the aggregate so that -** it can be accessed after all aggregates are computed. -** -** If the expression is an unbound variable marker (a question mark -** character '?' in the original SQL) then the Expr.iTable holds the index -** number for that variable. -** -** If the expression is a subquery then Expr.iColumn holds an integer -** register number containing the result of the subquery. If the -** subquery gives a constant result, then iTable is -1. If the subquery -** gives a different answer at different times during statement processing -** then iTable is the address of a subroutine that computes the subquery. -** -** If the Expr is of type OP_Column, and the table it is selecting from -** is a disk table or the "old.*" pseudo-table, then pTab points to the -** corresponding table definition. -** -** ALLOCATION NOTES: -** -** Expr objects can use a lot of memory space in database schema. To -** help reduce memory requirements, sometimes an Expr object will be -** truncated. And to reduce the number of memory allocations, sometimes -** two or more Expr objects will be stored in a single memory allocation, -** together with Expr.zToken strings. -** -** If the EP_Reduced and EP_TokenOnly flags are set when -** an Expr object is truncated. When EP_Reduced is set, then all -** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees -** are contained within the same memory allocation. Note, however, that -** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately -** allocated, regardless of whether or not EP_Reduced is set. -*/ -struct Expr { - u8 op; /* Operation performed by this node */ - char affinity; /* The affinity of the column or 0 if not a column */ - u16 flags; /* Various flags. EP_* See below */ - union { - char *zToken; /* Token value. Zero terminated and dequoted */ - int iValue; /* Integer value if EP_IntValue */ - } u; - - /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no - ** space is allocated for the fields below this point. An attempt to - ** access them will result in a segfault or malfunction. - *********************************************************************/ - - Expr *pLeft; /* Left subnode */ - Expr *pRight; /* Right subnode */ - union { - ExprList *pList; /* Function arguments or in " IN ( IN (