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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 z zb1mG7Glc!^x|1T^%r|uQZ>Gh!^voG!yLcxeO)KZa3}HfQnWf=eha~zm*(}Sn;@kh$ z65%`w{F&>d3ibj%UAMsEI>|VgfW4@|%4A&3=6H55+Zc)j>0h?9g~v6jEO(t$YF*DV zAIVbJv&=_wHTePak<2yjW*@>nZRp4N8YrGq4I6T1hjSR1#>|cg-95kzr5VLsGo6OH zYECSa*+n@=fskwplC;yHf2}o@?Y*u(WlrZ7YfQ}-cL%3U|C}r@b{$ZUftq(An7LpK z2Lh=HYi}Uf5TPZRa~52}7SYmkATC%$?aGx{b9V+9*5MMSKF1;5lJ#pVw@8Zn9Lz&} z7ib;K)w0+yV_>noCVmA(vPa(B*4pCgTchNoC3Gv|D;bH$tHhY@=cN-Xc?tji)Xz)% zSD*d=>D9bcu$rIb9MwK5W){Oz=TVZ@n`J9w#B7#}>9Q5@d#Ur==agC|?ZL0U#T4q+ zWKGc;t-rXhvRN);La_|F;E4ANKJ0Kb6e4MQ`eD-#dXgB4VdVnt%q%g{Zo279+}a38 zWlF?k#5_~cS;2{2%W<$?E_WVfFwank9EuqYNo<(_!mZGofmBGyJHrGk`5}+%n z4=0YQ5I@kRD>CiVwmBg-#m}t6LS;$f(%)t?GaAM-T z9F99(E12l*!W^hI?25V`G2389NR}RhazM8*yoXqizuf-wJSlTGGxm@{dUxx%ffCg`vfY-+aT>%)RyHMumCHIi zn8o(9DHhu_P5p!wlJ+j(o`Z>(chu7?ENZ_*F@b$2q(dsqU15r5hLhB&bd!eYEwbXAr+QV`rw zD(;rZUULO+W@zh*uJ1kgaGs>h7I)h$xqHnc^#nssn#8(GTnQ!)FL5Q9IGj(COdMK` zBol`TcGN7}haMXZbTC81(w879Ij6cHQ~d42XACk*={=?r zhXI{PDQ&Jh*juBnJJ?%SlU>=j?qYAf14o%J@F&f zo0VZX4#WC zs@xi(-~1npb)M`^q?9>`Zpp9itVCGg-W~6=xWFxzDE(j^TQGFY1A8<=ulk>HgUr$T z`9K4m>tM4#b20NY#5g!jPW;gPek57Ju+29u^<q z@j0$5GQ))dTpgYSt{s~KTmvjAaZCZ^EDKyCGybwPUkZ`=?=8)joGI9%?1_CHg_TvB zlIM2y#D`rysykWExUuNrH{p?hpYhpt_GyU}Q-3AQy-bl=m|oRg{WBD&v$El9YFm?i z>%=5Xx3o?=Q0P{()Egp`bsnBlXVYiOK0jOMM^Siye)=LC%7b}0gkxtg58r~n&TX!9 z&|t71R>0-!MsTPv;v7c2xkDSbsKTCmp2(9}mcvZpo)Y}s^yfTA{{s_BB>#0*=PbIL4I|2c3o#c}ivFW{)CuZuW5#SKq;ma=Q~LWq#IPT%icsX5OOacW$;?)aQvCtSv*% zW7++@wpHL%Q0#{OF>Vl=IHnxSVAPd#ZoQZT84W)30&`iIK{iO#_2*H8djC9b4AwBV z5N$k9y_Vhl4YHBnk$%v^fqZ0UVxQ7Tyw*f2zKTTn0860_E|WaNYt86`UMsL9nJW{= z)Fo&Pb)HcpcW$4?DN?#lwvZZka~+EWy@pS1orKrJoa|Iwls77*;~ZjE0()@lqKzZKV@kRn#cgvTuf%M=*}V7 zgV^mr$ITMfX}%Ra5N{)=TsK(0$QFuK+R?NZ8@jkB(QNv`Z7Ps zCry50p?k+h4Fcxvitc4TGP84w56H>G>193(JK{GLwm zbHVKtSK2 zSDY;eiC4)Wnly1#DcG@2Fvbm|4c-vz6mQ5YuSCdKov8|MT%DV&vj*sVj1UHg%Qx!W zdfgYr_bVoAoCHS3s5;AR>q21hlKv%J2Adr_8A3{UFWArzbzDIfB>8IHYfV-mG>4

(-nW{#;jm*{g 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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 (