1/******************************************************************************
2** This file is an amalgamation of many separate C source files from SQLite
3** version 3.8.7.2.  By combining all the individual C code files into this
4** single large file, the entire code can be compiled as a single translation
5** unit.  This allows many compilers to do optimizations that would not be
6** possible if the files were compiled separately.  Performance improvements
7** of 5% or more are commonly seen when SQLite is compiled as a single
8** translation unit.
9**
10** This file is all you need to compile SQLite.  To use SQLite in other
11** programs, you need this file and the "sqlite3.h" header file that defines
12** the programming interface to the SQLite library.  (If you do not have
13** the "sqlite3.h" header file at hand, you will find a copy embedded within
14** the text of this file.  Search for "Begin file sqlite3.h" to find the start
15** of the embedded sqlite3.h header file.) Additional code files may be needed
16** if you want a wrapper to interface SQLite with your choice of programming
17** language. The code for the "sqlite3" command-line shell is also in a
18** separate file. This file contains only code for the core SQLite library.
19*/
20#define SQLITE_CORE 1
21#define SQLITE_AMALGAMATION 1
22#ifndef SQLITE_PRIVATE
23# define SQLITE_PRIVATE static
24#endif
25#ifndef SQLITE_API
26# define SQLITE_API
27#endif
28/************** Begin file sqliteInt.h ***************************************/
29/*
30** 2001 September 15
31**
32** The author disclaims copyright to this source code.  In place of
33** a legal notice, here is a blessing:
34**
35**    May you do good and not evil.
36**    May you find forgiveness for yourself and forgive others.
37**    May you share freely, never taking more than you give.
38**
39*************************************************************************
40** Internal interface definitions for SQLite.
41**
42*/
43#ifndef _SQLITEINT_H_
44#define _SQLITEINT_H_
45
46/*
47** These #defines should enable >2GB file support on POSIX if the
48** underlying operating system supports it.  If the OS lacks
49** large file support, or if the OS is windows, these should be no-ops.
50**
51** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
52** system #includes.  Hence, this block of code must be the very first
53** code in all source files.
54**
55** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
56** on the compiler command line.  This is necessary if you are compiling
57** on a recent machine (ex: Red Hat 7.2) but you want your code to work
58** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2
59** without this option, LFS is enable.  But LFS does not exist in the kernel
60** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary
61** portability you should omit LFS.
62**
63** The previous paragraph was written in 2005.  (This paragraph is written
64** on 2008-11-28.) These days, all Linux kernels support large files, so
65** you should probably leave LFS enabled.  But some embedded platforms might
66** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
67**
68** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
69*/
70#ifndef SQLITE_DISABLE_LFS
71# define _LARGE_FILE       1
72# ifndef _FILE_OFFSET_BITS
73#   define _FILE_OFFSET_BITS 64
74# endif
75# define _LARGEFILE_SOURCE 1
76#endif
77
78/* Needed for various definitions... */
79#if defined(__GNUC__) && !defined(_GNU_SOURCE)
80# define _GNU_SOURCE
81#endif
82
83#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
84# define _BSD_SOURCE
85#endif
86
87/*
88** For MinGW, check to see if we can include the header file containing its
89** version information, among other things.  Normally, this internal MinGW
90** header file would [only] be included automatically by other MinGW header
91** files; however, the contained version information is now required by this
92** header file to work around binary compatibility issues (see below) and
93** this is the only known way to reliably obtain it.  This entire #if block
94** would be completely unnecessary if there was any other way of detecting
95** MinGW via their preprocessor (e.g. if they customized their GCC to define
96** some MinGW-specific macros).  When compiling for MinGW, either the
97** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
98** defined; otherwise, detection of conditions specific to MinGW will be
99** disabled.
100*/
101#if defined(_HAVE_MINGW_H)
102# include "mingw.h"
103#elif defined(_HAVE__MINGW_H)
104# include "_mingw.h"
105#endif
106
107/*
108** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
109** define is required to maintain binary compatibility with the MSVC runtime
110** library in use (e.g. for Windows XP).
111*/
112#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
113    defined(_WIN32) && !defined(_WIN64) && \
114    defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
115    defined(__MSVCRT__)
116# define _USE_32BIT_TIME_T
117#endif
118
119/* The public SQLite interface.  The _FILE_OFFSET_BITS macro must appear
120** first in QNX.  Also, the _USE_32BIT_TIME_T macro must appear first for
121** MinGW.
122*/
123/************** Include sqlite3.h in the middle of sqliteInt.h ***************/
124/************** Begin file sqlite3.h *****************************************/
125/*
126** 2001 September 15
127**
128** The author disclaims copyright to this source code.  In place of
129** a legal notice, here is a blessing:
130**
131**    May you do good and not evil.
132**    May you find forgiveness for yourself and forgive others.
133**    May you share freely, never taking more than you give.
134**
135*************************************************************************
136** This header file defines the interface that the SQLite library
137** presents to client programs.  If a C-function, structure, datatype,
138** or constant definition does not appear in this file, then it is
139** not a published API of SQLite, is subject to change without
140** notice, and should not be referenced by programs that use SQLite.
141**
142** Some of the definitions that are in this file are marked as
143** "experimental".  Experimental interfaces are normally new
144** features recently added to SQLite.  We do not anticipate changes
145** to experimental interfaces but reserve the right to make minor changes
146** if experience from use "in the wild" suggest such changes are prudent.
147**
148** The official C-language API documentation for SQLite is derived
149** from comments in this file.  This file is the authoritative source
150** on how SQLite interfaces are suppose to operate.
151**
152** The name of this file under configuration management is "sqlite.h.in".
153** The makefile makes some minor changes to this file (such as inserting
154** the version number) and changes its name to "sqlite3.h" as
155** part of the build process.
156*/
157#ifndef _SQLITE3_H_
158#define _SQLITE3_H_
159#include <stdarg.h>     /* Needed for the definition of va_list */
160
161/*
162** Make sure we can call this stuff from C++.
163*/
164#if 0
165extern "C" {
166#endif
167
168
169/*
170** Add the ability to override 'extern'
171*/
172#ifndef SQLITE_EXTERN
173# define SQLITE_EXTERN extern
174#endif
175
176#ifndef SQLITE_API
177# define SQLITE_API
178#endif
179
180
181/*
182** These no-op macros are used in front of interfaces to mark those
183** interfaces as either deprecated or experimental.  New applications
184** should not use deprecated interfaces - they are support for backwards
185** compatibility only.  Application writers should be aware that
186** experimental interfaces are subject to change in point releases.
187**
188** These macros used to resolve to various kinds of compiler magic that
189** would generate warning messages when they were used.  But that
190** compiler magic ended up generating such a flurry of bug reports
191** that we have taken it all out and gone back to using simple
192** noop macros.
193*/
194#define SQLITE_DEPRECATED
195#define SQLITE_EXPERIMENTAL
196
197/*
198** Ensure these symbols were not defined by some previous header file.
199*/
200#ifdef SQLITE_VERSION
201# undef SQLITE_VERSION
202#endif
203#ifdef SQLITE_VERSION_NUMBER
204# undef SQLITE_VERSION_NUMBER
205#endif
206
207/*
208** CAPI3REF: Compile-Time Library Version Numbers
209**
210** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
211** evaluates to a string literal that is the SQLite version in the
212** format "X.Y.Z" where X is the major version number (always 3 for
213** SQLite3) and Y is the minor version number and Z is the release number.)^
214** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
215** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
216** numbers used in [SQLITE_VERSION].)^
217** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
218** be larger than the release from which it is derived.  Either Y will
219** be held constant and Z will be incremented or else Y will be incremented
220** and Z will be reset to zero.
221**
222** Since version 3.6.18, SQLite source code has been stored in the
223** <a href="http://www.fossil-scm.org/">Fossil configuration management
224** system</a>.  ^The SQLITE_SOURCE_ID macro evaluates to
225** a string which identifies a particular check-in of SQLite
226** within its configuration management system.  ^The SQLITE_SOURCE_ID
227** string contains the date and time of the check-in (UTC) and an SHA1
228** hash of the entire source tree.
229**
230** See also: [sqlite3_libversion()],
231** [sqlite3_libversion_number()], [sqlite3_sourceid()],
232** [sqlite_version()] and [sqlite_source_id()].
233*/
234#define SQLITE_VERSION        "3.8.7.2"
235#define SQLITE_VERSION_NUMBER 3008007
236#define SQLITE_SOURCE_ID      "2014-11-18 20:57:56 2ab564bf9655b7c7b97ab85cafc8a48329b27f93"
237
238/*
239** CAPI3REF: Run-Time Library Version Numbers
240** KEYWORDS: sqlite3_version, sqlite3_sourceid
241**
242** These interfaces provide the same information as the [SQLITE_VERSION],
243** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
244** but are associated with the library instead of the header file.  ^(Cautious
245** programmers might include assert() statements in their application to
246** verify that values returned by these interfaces match the macros in
247** the header, and thus insure that the application is
248** compiled with matching library and header files.
249**
250** <blockquote><pre>
251** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
252** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
253** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
254** </pre></blockquote>)^
255**
256** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
257** macro.  ^The sqlite3_libversion() function returns a pointer to the
258** to the sqlite3_version[] string constant.  The sqlite3_libversion()
259** function is provided for use in DLLs since DLL users usually do not have
260** direct access to string constants within the DLL.  ^The
261** sqlite3_libversion_number() function returns an integer equal to
262** [SQLITE_VERSION_NUMBER].  ^The sqlite3_sourceid() function returns
263** a pointer to a string constant whose value is the same as the
264** [SQLITE_SOURCE_ID] C preprocessor macro.
265**
266** See also: [sqlite_version()] and [sqlite_source_id()].
267*/
268SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;
269SQLITE_API const char *sqlite3_libversion(void);
270SQLITE_API const char *sqlite3_sourceid(void);
271SQLITE_API int sqlite3_libversion_number(void);
272
273/*
274** CAPI3REF: Run-Time Library Compilation Options Diagnostics
275**
276** ^The sqlite3_compileoption_used() function returns 0 or 1
277** indicating whether the specified option was defined at
278** compile time.  ^The SQLITE_ prefix may be omitted from the
279** option name passed to sqlite3_compileoption_used().
280**
281** ^The sqlite3_compileoption_get() function allows iterating
282** over the list of options that were defined at compile time by
283** returning the N-th compile time option string.  ^If N is out of range,
284** sqlite3_compileoption_get() returns a NULL pointer.  ^The SQLITE_
285** prefix is omitted from any strings returned by
286** sqlite3_compileoption_get().
287**
288** ^Support for the diagnostic functions sqlite3_compileoption_used()
289** and sqlite3_compileoption_get() may be omitted by specifying the
290** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
291**
292** See also: SQL functions [sqlite_compileoption_used()] and
293** [sqlite_compileoption_get()] and the [compile_options pragma].
294*/
295#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
296SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
297SQLITE_API const char *sqlite3_compileoption_get(int N);
298#endif
299
300/*
301** CAPI3REF: Test To See If The Library Is Threadsafe
302**
303** ^The sqlite3_threadsafe() function returns zero if and only if
304** SQLite was compiled with mutexing code omitted due to the
305** [SQLITE_THREADSAFE] compile-time option being set to 0.
306**
307** SQLite can be compiled with or without mutexes.  When
308** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
309** are enabled and SQLite is threadsafe.  When the
310** [SQLITE_THREADSAFE] macro is 0,
311** the mutexes are omitted.  Without the mutexes, it is not safe
312** to use SQLite concurrently from more than one thread.
313**
314** Enabling mutexes incurs a measurable performance penalty.
315** So if speed is of utmost importance, it makes sense to disable
316** the mutexes.  But for maximum safety, mutexes should be enabled.
317** ^The default behavior is for mutexes to be enabled.
318**
319** This interface can be used by an application to make sure that the
320** version of SQLite that it is linking against was compiled with
321** the desired setting of the [SQLITE_THREADSAFE] macro.
322**
323** This interface only reports on the compile-time mutex setting
324** of the [SQLITE_THREADSAFE] flag.  If SQLite is compiled with
325** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
326** can be fully or partially disabled using a call to [sqlite3_config()]
327** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
328** or [SQLITE_CONFIG_MUTEX].  ^(The return value of the
329** sqlite3_threadsafe() function shows only the compile-time setting of
330** thread safety, not any run-time changes to that setting made by
331** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
332** is unchanged by calls to sqlite3_config().)^
333**
334** See the [threading mode] documentation for additional information.
335*/
336SQLITE_API int sqlite3_threadsafe(void);
337
338/*
339** CAPI3REF: Database Connection Handle
340** KEYWORDS: {database connection} {database connections}
341**
342** Each open SQLite database is represented by a pointer to an instance of
343** the opaque structure named "sqlite3".  It is useful to think of an sqlite3
344** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and
345** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
346** and [sqlite3_close_v2()] are its destructors.  There are many other
347** interfaces (such as
348** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
349** [sqlite3_busy_timeout()] to name but three) that are methods on an
350** sqlite3 object.
351*/
352typedef struct sqlite3 sqlite3;
353
354/*
355** CAPI3REF: 64-Bit Integer Types
356** KEYWORDS: sqlite_int64 sqlite_uint64
357**
358** Because there is no cross-platform way to specify 64-bit integer types
359** SQLite includes typedefs for 64-bit signed and unsigned integers.
360**
361** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
362** The sqlite_int64 and sqlite_uint64 types are supported for backwards
363** compatibility only.
364**
365** ^The sqlite3_int64 and sqlite_int64 types can store integer values
366** between -9223372036854775808 and +9223372036854775807 inclusive.  ^The
367** sqlite3_uint64 and sqlite_uint64 types can store integer values
368** between 0 and +18446744073709551615 inclusive.
369*/
370#ifdef SQLITE_INT64_TYPE
371  typedef SQLITE_INT64_TYPE sqlite_int64;
372  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
373#elif defined(_MSC_VER) || defined(__BORLANDC__)
374  typedef __int64 sqlite_int64;
375  typedef unsigned __int64 sqlite_uint64;
376#else
377  typedef long long int sqlite_int64;
378  typedef unsigned long long int sqlite_uint64;
379#endif
380typedef sqlite_int64 sqlite3_int64;
381typedef sqlite_uint64 sqlite3_uint64;
382
383/*
384** If compiling for a processor that lacks floating point support,
385** substitute integer for floating-point.
386*/
387#ifdef SQLITE_OMIT_FLOATING_POINT
388# define double sqlite3_int64
389#endif
390
391/*
392** CAPI3REF: Closing A Database Connection
393**
394** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors
395** for the [sqlite3] object.
396** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if
397** the [sqlite3] object is successfully destroyed and all associated
398** resources are deallocated.
399**
400** ^If the database connection is associated with unfinalized prepared
401** statements or unfinished sqlite3_backup objects then sqlite3_close()
402** will leave the database connection open and return [SQLITE_BUSY].
403** ^If sqlite3_close_v2() is called with unfinalized prepared statements
404** and/or unfinished sqlite3_backups, then the database connection becomes
405** an unusable "zombie" which will automatically be deallocated when the
406** last prepared statement is finalized or the last sqlite3_backup is
407** finished.  The sqlite3_close_v2() interface is intended for use with
408** host languages that are garbage collected, and where the order in which
409** destructors are called is arbitrary.
410**
411** Applications should [sqlite3_finalize | finalize] all [prepared statements],
412** [sqlite3_blob_close | close] all [BLOB handles], and
413** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated
414** with the [sqlite3] object prior to attempting to close the object.  ^If
415** sqlite3_close_v2() is called on a [database connection] that still has
416** outstanding [prepared statements], [BLOB handles], and/or
417** [sqlite3_backup] objects then it returns [SQLITE_OK] and the deallocation
418** of resources is deferred until all [prepared statements], [BLOB handles],
419** and [sqlite3_backup] objects are also destroyed.
420**
421** ^If an [sqlite3] object is destroyed while a transaction is open,
422** the transaction is automatically rolled back.
423**
424** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)]
425** must be either a NULL
426** pointer or an [sqlite3] object pointer obtained
427** from [sqlite3_open()], [sqlite3_open16()], or
428** [sqlite3_open_v2()], and not previously closed.
429** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer
430** argument is a harmless no-op.
431*/
432SQLITE_API int sqlite3_close(sqlite3*);
433SQLITE_API int sqlite3_close_v2(sqlite3*);
434
435/*
436** The type for a callback function.
437** This is legacy and deprecated.  It is included for historical
438** compatibility and is not documented.
439*/
440typedef int (*sqlite3_callback)(void*,int,char**, char**);
441
442/*
443** CAPI3REF: One-Step Query Execution Interface
444**
445** The sqlite3_exec() interface is a convenience wrapper around
446** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
447** that allows an application to run multiple statements of SQL
448** without having to use a lot of C code.
449**
450** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
451** semicolon-separate SQL statements passed into its 2nd argument,
452** in the context of the [database connection] passed in as its 1st
453** argument.  ^If the callback function of the 3rd argument to
454** sqlite3_exec() is not NULL, then it is invoked for each result row
455** coming out of the evaluated SQL statements.  ^The 4th argument to
456** sqlite3_exec() is relayed through to the 1st argument of each
457** callback invocation.  ^If the callback pointer to sqlite3_exec()
458** is NULL, then no callback is ever invoked and result rows are
459** ignored.
460**
461** ^If an error occurs while evaluating the SQL statements passed into
462** sqlite3_exec(), then execution of the current statement stops and
463** subsequent statements are skipped.  ^If the 5th parameter to sqlite3_exec()
464** is not NULL then any error message is written into memory obtained
465** from [sqlite3_malloc()] and passed back through the 5th parameter.
466** To avoid memory leaks, the application should invoke [sqlite3_free()]
467** on error message strings returned through the 5th parameter of
468** of sqlite3_exec() after the error message string is no longer needed.
469** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
470** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
471** NULL before returning.
472**
473** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
474** routine returns SQLITE_ABORT without invoking the callback again and
475** without running any subsequent SQL statements.
476**
477** ^The 2nd argument to the sqlite3_exec() callback function is the
478** number of columns in the result.  ^The 3rd argument to the sqlite3_exec()
479** callback is an array of pointers to strings obtained as if from
480** [sqlite3_column_text()], one for each column.  ^If an element of a
481** result row is NULL then the corresponding string pointer for the
482** sqlite3_exec() callback is a NULL pointer.  ^The 4th argument to the
483** sqlite3_exec() callback is an array of pointers to strings where each
484** entry represents the name of corresponding result column as obtained
485** from [sqlite3_column_name()].
486**
487** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer
488** to an empty string, or a pointer that contains only whitespace and/or
489** SQL comments, then no SQL statements are evaluated and the database
490** is not changed.
491**
492** Restrictions:
493**
494** <ul>
495** <li> The application must insure that the 1st parameter to sqlite3_exec()
496**      is a valid and open [database connection].
497** <li> The application must not close the [database connection] specified by
498**      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
499** <li> The application must not modify the SQL statement text passed into
500**      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
501** </ul>
502*/
503SQLITE_API int sqlite3_exec(
504  sqlite3*,                                  /* An open database */
505  const char *sql,                           /* SQL to be evaluated */
506  int (*callback)(void*,int,char**,char**),  /* Callback function */
507  void *,                                    /* 1st argument to callback */
508  char **errmsg                              /* Error msg written here */
509);
510
511/*
512** CAPI3REF: Result Codes
513** KEYWORDS: {result code definitions}
514**
515** Many SQLite functions return an integer result code from the set shown
516** here in order to indicate success or failure.
517**
518** New error codes may be added in future versions of SQLite.
519**
520** See also: [extended result code definitions]
521*/
522#define SQLITE_OK           0   /* Successful result */
523/* beginning-of-error-codes */
524#define SQLITE_ERROR        1   /* SQL error or missing database */
525#define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
526#define SQLITE_PERM         3   /* Access permission denied */
527#define SQLITE_ABORT        4   /* Callback routine requested an abort */
528#define SQLITE_BUSY         5   /* The database file is locked */
529#define SQLITE_LOCKED       6   /* A table in the database is locked */
530#define SQLITE_NOMEM        7   /* A malloc() failed */
531#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
532#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
533#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
534#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
535#define SQLITE_NOTFOUND    12   /* Unknown opcode in sqlite3_file_control() */
536#define SQLITE_FULL        13   /* Insertion failed because database is full */
537#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
538#define SQLITE_PROTOCOL    15   /* Database lock protocol error */
539#define SQLITE_EMPTY       16   /* Database is empty */
540#define SQLITE_SCHEMA      17   /* The database schema changed */
541#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
542#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
543#define SQLITE_MISMATCH    20   /* Data type mismatch */
544#define SQLITE_MISUSE      21   /* Library used incorrectly */
545#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
546#define SQLITE_AUTH        23   /* Authorization denied */
547#define SQLITE_FORMAT      24   /* Auxiliary database format error */
548#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
549#define SQLITE_NOTADB      26   /* File opened that is not a database file */
550#define SQLITE_NOTICE      27   /* Notifications from sqlite3_log() */
551#define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */
552#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
553#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
554/* end-of-error-codes */
555
556/*
557** CAPI3REF: Extended Result Codes
558** KEYWORDS: {extended result code definitions}
559**
560** In its default configuration, SQLite API routines return one of 30 integer
561** [result codes].  However, experience has shown that many of
562** these result codes are too coarse-grained.  They do not provide as
563** much information about problems as programmers might like.  In an effort to
564** address this, newer versions of SQLite (version 3.3.8 and later) include
565** support for additional result codes that provide more detailed information
566** about errors. These [extended result codes] are enabled or disabled
567** on a per database connection basis using the
568** [sqlite3_extended_result_codes()] API.  Or, the extended code for
569** the most recent error can be obtained using
570** [sqlite3_extended_errcode()].
571*/
572#define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
573#define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
574#define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
575#define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))
576#define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))
577#define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))
578#define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))
579#define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))
580#define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
581#define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
582#define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
583#define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
584#define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
585#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
586#define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
587#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
588#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
589#define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
590#define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
591#define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
592#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
593#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
594#define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
595#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
596#define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
597#define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
598#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
599#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
600#define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
601#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
602#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
603#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
604#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
605#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
606#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
607#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
608#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
609#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
610#define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
611#define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
612#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
613#define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
614#define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
615#define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
616#define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
617#define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
618#define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
619#define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
620#define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
621#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
622#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
623#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
624#define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
625
626/*
627** CAPI3REF: Flags For File Open Operations
628**
629** These bit values are intended for use in the
630** 3rd parameter to the [sqlite3_open_v2()] interface and
631** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
632*/
633#define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
634#define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
635#define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */
636#define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
637#define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
638#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */
639#define SQLITE_OPEN_URI              0x00000040  /* Ok for sqlite3_open_v2() */
640#define SQLITE_OPEN_MEMORY           0x00000080  /* Ok for sqlite3_open_v2() */
641#define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */
642#define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */
643#define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */
644#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */
645#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */
646#define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
647#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */
648#define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
649#define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
650#define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
651#define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
652#define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
653
654/* Reserved:                         0x00F00000 */
655
656/*
657** CAPI3REF: Device Characteristics
658**
659** The xDeviceCharacteristics method of the [sqlite3_io_methods]
660** object returns an integer which is a vector of these
661** bit values expressing I/O characteristics of the mass storage
662** device that holds the file that the [sqlite3_io_methods]
663** refers to.
664**
665** The SQLITE_IOCAP_ATOMIC property means that all writes of
666** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
667** mean that writes of blocks that are nnn bytes in size and
668** are aligned to an address which is an integer multiple of
669** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
670** that when data is appended to a file, the data is appended
671** first then the size of the file is extended, never the other
672** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
673** information is written to disk in the same order as calls
674** to xWrite().  The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that
675** after reboot following a crash or power loss, the only bytes in a
676** file that were written at the application level might have changed
677** and that adjacent bytes, even bytes within the same sector are
678** guaranteed to be unchanged.  The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
679** flag indicate that a file cannot be deleted when open.  The
680** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on
681** read-only media and cannot be changed even by processes with
682** elevated privileges.
683*/
684#define SQLITE_IOCAP_ATOMIC                 0x00000001
685#define SQLITE_IOCAP_ATOMIC512              0x00000002
686#define SQLITE_IOCAP_ATOMIC1K               0x00000004
687#define SQLITE_IOCAP_ATOMIC2K               0x00000008
688#define SQLITE_IOCAP_ATOMIC4K               0x00000010
689#define SQLITE_IOCAP_ATOMIC8K               0x00000020
690#define SQLITE_IOCAP_ATOMIC16K              0x00000040
691#define SQLITE_IOCAP_ATOMIC32K              0x00000080
692#define SQLITE_IOCAP_ATOMIC64K              0x00000100
693#define SQLITE_IOCAP_SAFE_APPEND            0x00000200
694#define SQLITE_IOCAP_SEQUENTIAL             0x00000400
695#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
696#define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
697#define SQLITE_IOCAP_IMMUTABLE              0x00002000
698
699/*
700** CAPI3REF: File Locking Levels
701**
702** SQLite uses one of these integer values as the second
703** argument to calls it makes to the xLock() and xUnlock() methods
704** of an [sqlite3_io_methods] object.
705*/
706#define SQLITE_LOCK_NONE          0
707#define SQLITE_LOCK_SHARED        1
708#define SQLITE_LOCK_RESERVED      2
709#define SQLITE_LOCK_PENDING       3
710#define SQLITE_LOCK_EXCLUSIVE     4
711
712/*
713** CAPI3REF: Synchronization Type Flags
714**
715** When SQLite invokes the xSync() method of an
716** [sqlite3_io_methods] object it uses a combination of
717** these integer values as the second argument.
718**
719** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
720** sync operation only needs to flush data to mass storage.  Inode
721** information need not be flushed. If the lower four bits of the flag
722** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.
723** If the lower four bits equal SQLITE_SYNC_FULL, that means
724** to use Mac OS X style fullsync instead of fsync().
725**
726** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
727** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL
728** settings.  The [synchronous pragma] determines when calls to the
729** xSync VFS method occur and applies uniformly across all platforms.
730** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how
731** energetic or rigorous or forceful the sync operations are and
732** only make a difference on Mac OSX for the default SQLite code.
733** (Third-party VFS implementations might also make the distinction
734** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the
735** operating systems natively supported by SQLite, only Mac OSX
736** cares about the difference.)
737*/
738#define SQLITE_SYNC_NORMAL        0x00002
739#define SQLITE_SYNC_FULL          0x00003
740#define SQLITE_SYNC_DATAONLY      0x00010
741
742/*
743** CAPI3REF: OS Interface Open File Handle
744**
745** An [sqlite3_file] object represents an open file in the
746** [sqlite3_vfs | OS interface layer].  Individual OS interface
747** implementations will
748** want to subclass this object by appending additional fields
749** for their own use.  The pMethods entry is a pointer to an
750** [sqlite3_io_methods] object that defines methods for performing
751** I/O operations on the open file.
752*/
753typedef struct sqlite3_file sqlite3_file;
754struct sqlite3_file {
755  const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
756};
757
758/*
759** CAPI3REF: OS Interface File Virtual Methods Object
760**
761** Every file opened by the [sqlite3_vfs.xOpen] method populates an
762** [sqlite3_file] object (or, more commonly, a subclass of the
763** [sqlite3_file] object) with a pointer to an instance of this object.
764** This object defines the methods used to perform various operations
765** against the open file represented by the [sqlite3_file] object.
766**
767** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element
768** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
769** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed.  The
770** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]
771** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
772** to NULL.
773**
774** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
775** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
776** The second choice is a Mac OS X style fullsync.  The [SQLITE_SYNC_DATAONLY]
777** flag may be ORed in to indicate that only the data of the file
778** and not its inode needs to be synced.
779**
780** The integer values to xLock() and xUnlock() are one of
781** <ul>
782** <li> [SQLITE_LOCK_NONE],
783** <li> [SQLITE_LOCK_SHARED],
784** <li> [SQLITE_LOCK_RESERVED],
785** <li> [SQLITE_LOCK_PENDING], or
786** <li> [SQLITE_LOCK_EXCLUSIVE].
787** </ul>
788** xLock() increases the lock. xUnlock() decreases the lock.
789** The xCheckReservedLock() method checks whether any database connection,
790** either in this process or in some other process, is holding a RESERVED,
791** PENDING, or EXCLUSIVE lock on the file.  It returns true
792** if such a lock exists and false otherwise.
793**
794** The xFileControl() method is a generic interface that allows custom
795** VFS implementations to directly control an open file using the
796** [sqlite3_file_control()] interface.  The second "op" argument is an
797** integer opcode.  The third argument is a generic pointer intended to
798** point to a structure that may contain arguments or space in which to
799** write return values.  Potential uses for xFileControl() might be
800** functions to enable blocking locks with timeouts, to change the
801** locking strategy (for example to use dot-file locks), to inquire
802** about the status of a lock, or to break stale locks.  The SQLite
803** core reserves all opcodes less than 100 for its own use.
804** A [file control opcodes | list of opcodes] less than 100 is available.
805** Applications that define a custom xFileControl method should use opcodes
806** greater than 100 to avoid conflicts.  VFS implementations should
807** return [SQLITE_NOTFOUND] for file control opcodes that they do not
808** recognize.
809**
810** The xSectorSize() method returns the sector size of the
811** device that underlies the file.  The sector size is the
812** minimum write that can be performed without disturbing
813** other bytes in the file.  The xDeviceCharacteristics()
814** method returns a bit vector describing behaviors of the
815** underlying device:
816**
817** <ul>
818** <li> [SQLITE_IOCAP_ATOMIC]
819** <li> [SQLITE_IOCAP_ATOMIC512]
820** <li> [SQLITE_IOCAP_ATOMIC1K]
821** <li> [SQLITE_IOCAP_ATOMIC2K]
822** <li> [SQLITE_IOCAP_ATOMIC4K]
823** <li> [SQLITE_IOCAP_ATOMIC8K]
824** <li> [SQLITE_IOCAP_ATOMIC16K]
825** <li> [SQLITE_IOCAP_ATOMIC32K]
826** <li> [SQLITE_IOCAP_ATOMIC64K]
827** <li> [SQLITE_IOCAP_SAFE_APPEND]
828** <li> [SQLITE_IOCAP_SEQUENTIAL]
829** </ul>
830**
831** The SQLITE_IOCAP_ATOMIC property means that all writes of
832** any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
833** mean that writes of blocks that are nnn bytes in size and
834** are aligned to an address which is an integer multiple of
835** nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
836** that when data is appended to a file, the data is appended
837** first then the size of the file is extended, never the other
838** way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
839** information is written to disk in the same order as calls
840** to xWrite().
841**
842** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
843** in the unread portions of the buffer with zeros.  A VFS that
844** fails to zero-fill short reads might seem to work.  However,
845** failure to zero-fill short reads will eventually lead to
846** database corruption.
847*/
848typedef struct sqlite3_io_methods sqlite3_io_methods;
849struct sqlite3_io_methods {
850  int iVersion;
851  int (*xClose)(sqlite3_file*);
852  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
853  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
854  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
855  int (*xSync)(sqlite3_file*, int flags);
856  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
857  int (*xLock)(sqlite3_file*, int);
858  int (*xUnlock)(sqlite3_file*, int);
859  int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);
860  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
861  int (*xSectorSize)(sqlite3_file*);
862  int (*xDeviceCharacteristics)(sqlite3_file*);
863  /* Methods above are valid for version 1 */
864  int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
865  int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
866  void (*xShmBarrier)(sqlite3_file*);
867  int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
868  /* Methods above are valid for version 2 */
869  int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
870  int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);
871  /* Methods above are valid for version 3 */
872  /* Additional methods may be added in future releases */
873};
874
875/*
876** CAPI3REF: Standard File Control Opcodes
877** KEYWORDS: {file control opcodes} {file control opcode}
878**
879** These integer constants are opcodes for the xFileControl method
880** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
881** interface.
882**
883** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
884** opcode causes the xFileControl method to write the current state of
885** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
886** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
887** into an integer that the pArg argument points to. This capability
888** is used during testing and only needs to be supported when SQLITE_TEST
889** is defined.
890** <ul>
891** <li>[[SQLITE_FCNTL_SIZE_HINT]]
892** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
893** layer a hint of how large the database file will grow to be during the
894** current transaction.  This hint is not guaranteed to be accurate but it
895** is often close.  The underlying VFS might choose to preallocate database
896** file space based on this hint in order to help writes to the database
897** file run faster.
898**
899** <li>[[SQLITE_FCNTL_CHUNK_SIZE]]
900** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
901** extends and truncates the database file in chunks of a size specified
902** by the user. The fourth argument to [sqlite3_file_control()] should
903** point to an integer (type int) containing the new chunk-size to use
904** for the nominated database. Allocating database file space in large
905** chunks (say 1MB at a time), may reduce file-system fragmentation and
906** improve performance on some systems.
907**
908** <li>[[SQLITE_FCNTL_FILE_POINTER]]
909** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
910** to the [sqlite3_file] object associated with a particular database
911** connection.  See the [sqlite3_file_control()] documentation for
912** additional information.
913**
914** <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
915** No longer in use.
916**
917** <li>[[SQLITE_FCNTL_SYNC]]
918** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and
919** sent to the VFS immediately before the xSync method is invoked on a
920** database file descriptor. Or, if the xSync method is not invoked
921** because the user has configured SQLite with
922** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place
923** of the xSync method. In most cases, the pointer argument passed with
924** this file-control is NULL. However, if the database file is being synced
925** as part of a multi-database commit, the argument points to a nul-terminated
926** string containing the transactions master-journal file name. VFSes that
927** do not need this signal should silently ignore this opcode. Applications
928** should not call [sqlite3_file_control()] with this opcode as doing so may
929** disrupt the operation of the specialized VFSes that do require it.
930**
931** <li>[[SQLITE_FCNTL_COMMIT_PHASETWO]]
932** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite
933** and sent to the VFS after a transaction has been committed immediately
934** but before the database is unlocked. VFSes that do not need this signal
935** should silently ignore this opcode. Applications should not call
936** [sqlite3_file_control()] with this opcode as doing so may disrupt the
937** operation of the specialized VFSes that do require it.
938**
939** <li>[[SQLITE_FCNTL_WIN32_AV_RETRY]]
940** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic
941** retry counts and intervals for certain disk I/O operations for the
942** windows [VFS] in order to provide robustness in the presence of
943** anti-virus programs.  By default, the windows VFS will retry file read,
944** file write, and file delete operations up to 10 times, with a delay
945** of 25 milliseconds before the first retry and with the delay increasing
946** by an additional 25 milliseconds with each subsequent retry.  This
947** opcode allows these two values (10 retries and 25 milliseconds of delay)
948** to be adjusted.  The values are changed for all database connections
949** within the same process.  The argument is a pointer to an array of two
950** integers where the first integer i the new retry count and the second
951** integer is the delay.  If either integer is negative, then the setting
952** is not changed but instead the prior value of that setting is written
953** into the array entry, allowing the current retry settings to be
954** interrogated.  The zDbName parameter is ignored.
955**
956** <li>[[SQLITE_FCNTL_PERSIST_WAL]]
957** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
958** persistent [WAL | Write Ahead Log] setting.  By default, the auxiliary
959** write ahead log and shared memory files used for transaction control
960** are automatically deleted when the latest connection to the database
961** closes.  Setting persistent WAL mode causes those files to persist after
962** close.  Persisting the files is useful when other processes that do not
963** have write permission on the directory containing the database file want
964** to read the database file, as the WAL and shared memory files must exist
965** in order for the database to be readable.  The fourth parameter to
966** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
967** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
968** WAL mode.  If the integer is -1, then it is overwritten with the current
969** WAL persistence setting.
970**
971** <li>[[SQLITE_FCNTL_POWERSAFE_OVERWRITE]]
972** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
973** persistent "powersafe-overwrite" or "PSOW" setting.  The PSOW setting
974** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the
975** xDeviceCharacteristics methods. The fourth parameter to
976** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
977** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
978** mode.  If the integer is -1, then it is overwritten with the current
979** zero-damage mode setting.
980**
981** <li>[[SQLITE_FCNTL_OVERWRITE]]
982** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening
983** a write transaction to indicate that, unless it is rolled back for some
984** reason, the entire database file will be overwritten by the current
985** transaction. This is used by VACUUM operations.
986**
987** <li>[[SQLITE_FCNTL_VFSNAME]]
988** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
989** all [VFSes] in the VFS stack.  The names are of all VFS shims and the
990** final bottom-level VFS are written into memory obtained from
991** [sqlite3_malloc()] and the result is stored in the char* variable
992** that the fourth parameter of [sqlite3_file_control()] points to.
993** The caller is responsible for freeing the memory when done.  As with
994** all file-control actions, there is no guarantee that this will actually
995** do anything.  Callers should initialize the char* variable to a NULL
996** pointer in case this file-control is not implemented.  This file-control
997** is intended for diagnostic use only.
998**
999** <li>[[SQLITE_FCNTL_PRAGMA]]
1000** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA]
1001** file control is sent to the open [sqlite3_file] object corresponding
1002** to the database file to which the pragma statement refers. ^The argument
1003** to the [SQLITE_FCNTL_PRAGMA] file control is an array of
1004** pointers to strings (char**) in which the second element of the array
1005** is the name of the pragma and the third element is the argument to the
1006** pragma or NULL if the pragma has no argument.  ^The handler for an
1007** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element
1008** of the char** argument point to a string obtained from [sqlite3_mprintf()]
1009** or the equivalent and that string will become the result of the pragma or
1010** the error message if the pragma fails. ^If the
1011** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal
1012** [PRAGMA] processing continues.  ^If the [SQLITE_FCNTL_PRAGMA]
1013** file control returns [SQLITE_OK], then the parser assumes that the
1014** VFS has handled the PRAGMA itself and the parser generates a no-op
1015** prepared statement.  ^If the [SQLITE_FCNTL_PRAGMA] file control returns
1016** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
1017** that the VFS encountered an error while handling the [PRAGMA] and the
1018** compilation of the PRAGMA fails with an error.  ^The [SQLITE_FCNTL_PRAGMA]
1019** file control occurs at the beginning of pragma statement analysis and so
1020** it is able to override built-in [PRAGMA] statements.
1021**
1022** <li>[[SQLITE_FCNTL_BUSYHANDLER]]
1023** ^The [SQLITE_FCNTL_BUSYHANDLER]
1024** file-control may be invoked by SQLite on the database file handle
1025** shortly after it is opened in order to provide a custom VFS with access
1026** to the connections busy-handler callback. The argument is of type (void **)
1027** - an array of two (void *) values. The first (void *) actually points
1028** to a function of type (int (*)(void *)). In order to invoke the connections
1029** busy-handler, this function should be invoked with the second (void *) in
1030** the array as the only argument. If it returns non-zero, then the operation
1031** should be retried. If it returns zero, the custom VFS should abandon the
1032** current operation.
1033**
1034** <li>[[SQLITE_FCNTL_TEMPFILENAME]]
1035** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control
1036** to have SQLite generate a
1037** temporary filename using the same algorithm that is followed to generate
1038** temporary filenames for TEMP tables and other internal uses.  The
1039** argument should be a char** which will be filled with the filename
1040** written into memory obtained from [sqlite3_malloc()].  The caller should
1041** invoke [sqlite3_free()] on the result to avoid a memory leak.
1042**
1043** <li>[[SQLITE_FCNTL_MMAP_SIZE]]
1044** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the
1045** maximum number of bytes that will be used for memory-mapped I/O.
1046** The argument is a pointer to a value of type sqlite3_int64 that
1047** is an advisory maximum number of bytes in the file to memory map.  The
1048** pointer is overwritten with the old value.  The limit is not changed if
1049** the value originally pointed to is negative, and so the current limit
1050** can be queried by passing in a pointer to a negative number.  This
1051** file-control is used internally to implement [PRAGMA mmap_size].
1052**
1053** <li>[[SQLITE_FCNTL_TRACE]]
1054** The [SQLITE_FCNTL_TRACE] file control provides advisory information
1055** to the VFS about what the higher layers of the SQLite stack are doing.
1056** This file control is used by some VFS activity tracing [shims].
1057** The argument is a zero-terminated string.  Higher layers in the
1058** SQLite stack may generate instances of this file control if
1059** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
1060**
1061** <li>[[SQLITE_FCNTL_HAS_MOVED]]
1062** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a
1063** pointer to an integer and it writes a boolean into that integer depending
1064** on whether or not the file has been renamed, moved, or deleted since it
1065** was first opened.
1066**
1067** <li>[[SQLITE_FCNTL_WIN32_SET_HANDLE]]
1068** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging.  This
1069** opcode causes the xFileControl method to swap the file handle with the one
1070** pointed to by the pArg argument.  This capability is used during testing
1071** and only needs to be supported when SQLITE_TEST is defined.
1072**
1073** </ul>
1074*/
1075#define SQLITE_FCNTL_LOCKSTATE               1
1076#define SQLITE_GET_LOCKPROXYFILE             2
1077#define SQLITE_SET_LOCKPROXYFILE             3
1078#define SQLITE_LAST_ERRNO                    4
1079#define SQLITE_FCNTL_SIZE_HINT               5
1080#define SQLITE_FCNTL_CHUNK_SIZE              6
1081#define SQLITE_FCNTL_FILE_POINTER            7
1082#define SQLITE_FCNTL_SYNC_OMITTED            8
1083#define SQLITE_FCNTL_WIN32_AV_RETRY          9
1084#define SQLITE_FCNTL_PERSIST_WAL            10
1085#define SQLITE_FCNTL_OVERWRITE              11
1086#define SQLITE_FCNTL_VFSNAME                12
1087#define SQLITE_FCNTL_POWERSAFE_OVERWRITE    13
1088#define SQLITE_FCNTL_PRAGMA                 14
1089#define SQLITE_FCNTL_BUSYHANDLER            15
1090#define SQLITE_FCNTL_TEMPFILENAME           16
1091#define SQLITE_FCNTL_MMAP_SIZE              18
1092#define SQLITE_FCNTL_TRACE                  19
1093#define SQLITE_FCNTL_HAS_MOVED              20
1094#define SQLITE_FCNTL_SYNC                   21
1095#define SQLITE_FCNTL_COMMIT_PHASETWO        22
1096#define SQLITE_FCNTL_WIN32_SET_HANDLE       23
1097
1098/*
1099** CAPI3REF: Mutex Handle
1100**
1101** The mutex module within SQLite defines [sqlite3_mutex] to be an
1102** abstract type for a mutex object.  The SQLite core never looks
1103** at the internal representation of an [sqlite3_mutex].  It only
1104** deals with pointers to the [sqlite3_mutex] object.
1105**
1106** Mutexes are created using [sqlite3_mutex_alloc()].
1107*/
1108typedef struct sqlite3_mutex sqlite3_mutex;
1109
1110/*
1111** CAPI3REF: OS Interface Object
1112**
1113** An instance of the sqlite3_vfs object defines the interface between
1114** the SQLite core and the underlying operating system.  The "vfs"
1115** in the name of the object stands for "virtual file system".  See
1116** the [VFS | VFS documentation] for further information.
1117**
1118** The value of the iVersion field is initially 1 but may be larger in
1119** future versions of SQLite.  Additional fields may be appended to this
1120** object when the iVersion value is increased.  Note that the structure
1121** of the sqlite3_vfs object changes in the transaction between
1122** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1123** modified.
1124**
1125** The szOsFile field is the size of the subclassed [sqlite3_file]
1126** structure used by this VFS.  mxPathname is the maximum length of
1127** a pathname in this VFS.
1128**
1129** Registered sqlite3_vfs objects are kept on a linked list formed by
1130** the pNext pointer.  The [sqlite3_vfs_register()]
1131** and [sqlite3_vfs_unregister()] interfaces manage this list
1132** in a thread-safe way.  The [sqlite3_vfs_find()] interface
1133** searches the list.  Neither the application code nor the VFS
1134** implementation should use the pNext pointer.
1135**
1136** The pNext field is the only field in the sqlite3_vfs
1137** structure that SQLite will ever modify.  SQLite will only access
1138** or modify this field while holding a particular static mutex.
1139** The application should never modify anything within the sqlite3_vfs
1140** object once the object has been registered.
1141**
1142** The zName field holds the name of the VFS module.  The name must
1143** be unique across all VFS modules.
1144**
1145** [[sqlite3_vfs.xOpen]]
1146** ^SQLite guarantees that the zFilename parameter to xOpen
1147** is either a NULL pointer or string obtained
1148** from xFullPathname() with an optional suffix added.
1149** ^If a suffix is added to the zFilename parameter, it will
1150** consist of a single "-" character followed by no more than
1151** 11 alphanumeric and/or "-" characters.
1152** ^SQLite further guarantees that
1153** the string will be valid and unchanged until xClose() is
1154** called. Because of the previous sentence,
1155** the [sqlite3_file] can safely store a pointer to the
1156** filename if it needs to remember the filename for some reason.
1157** If the zFilename parameter to xOpen is a NULL pointer then xOpen
1158** must invent its own temporary name for the file.  ^Whenever the
1159** xFilename parameter is NULL it will also be the case that the
1160** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
1161**
1162** The flags argument to xOpen() includes all bits set in
1163** the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
1164** or [sqlite3_open16()] is used, then flags includes at least
1165** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
1166** If xOpen() opens a file read-only then it sets *pOutFlags to
1167** include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.
1168**
1169** ^(SQLite will also add one of the following flags to the xOpen()
1170** call, depending on the object being opened:
1171**
1172** <ul>
1173** <li>  [SQLITE_OPEN_MAIN_DB]
1174** <li>  [SQLITE_OPEN_MAIN_JOURNAL]
1175** <li>  [SQLITE_OPEN_TEMP_DB]
1176** <li>  [SQLITE_OPEN_TEMP_JOURNAL]
1177** <li>  [SQLITE_OPEN_TRANSIENT_DB]
1178** <li>  [SQLITE_OPEN_SUBJOURNAL]
1179** <li>  [SQLITE_OPEN_MASTER_JOURNAL]
1180** <li>  [SQLITE_OPEN_WAL]
1181** </ul>)^
1182**
1183** The file I/O implementation can use the object type flags to
1184** change the way it deals with files.  For example, an application
1185** that does not care about crash recovery or rollback might make
1186** the open of a journal file a no-op.  Writes to this journal would
1187** also be no-ops, and any attempt to read the journal would return
1188** SQLITE_IOERR.  Or the implementation might recognize that a database
1189** file will be doing page-aligned sector reads and writes in a random
1190** order and set up its I/O subsystem accordingly.
1191**
1192** SQLite might also add one of the following flags to the xOpen method:
1193**
1194** <ul>
1195** <li> [SQLITE_OPEN_DELETEONCLOSE]
1196** <li> [SQLITE_OPEN_EXCLUSIVE]
1197** </ul>
1198**
1199** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
1200** deleted when it is closed.  ^The [SQLITE_OPEN_DELETEONCLOSE]
1201** will be set for TEMP databases and their journals, transient
1202** databases, and subjournals.
1203**
1204** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
1205** with the [SQLITE_OPEN_CREATE] flag, which are both directly
1206** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
1207** API.  The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
1208** SQLITE_OPEN_CREATE, is used to indicate that file should always
1209** be created, and that it is an error if it already exists.
1210** It is <i>not</i> used to indicate the file should be opened
1211** for exclusive access.
1212**
1213** ^At least szOsFile bytes of memory are allocated by SQLite
1214** to hold the  [sqlite3_file] structure passed as the third
1215** argument to xOpen.  The xOpen method does not have to
1216** allocate the structure; it should just fill it in.  Note that
1217** the xOpen method must set the sqlite3_file.pMethods to either
1218** a valid [sqlite3_io_methods] object or to NULL.  xOpen must do
1219** this even if the open fails.  SQLite expects that the sqlite3_file.pMethods
1220** element will be valid after xOpen returns regardless of the success
1221** or failure of the xOpen call.
1222**
1223** [[sqlite3_vfs.xAccess]]
1224** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
1225** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
1226** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
1227** to test whether a file is at least readable.   The file can be a
1228** directory.
1229**
1230** ^SQLite will always allocate at least mxPathname+1 bytes for the
1231** output buffer xFullPathname.  The exact size of the output buffer
1232** is also passed as a parameter to both  methods. If the output buffer
1233** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
1234** handled as a fatal error by SQLite, vfs implementations should endeavor
1235** to prevent this by setting mxPathname to a sufficiently large value.
1236**
1237** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
1238** interfaces are not strictly a part of the filesystem, but they are
1239** included in the VFS structure for completeness.
1240** The xRandomness() function attempts to return nBytes bytes
1241** of good-quality randomness into zOut.  The return value is
1242** the actual number of bytes of randomness obtained.
1243** The xSleep() method causes the calling thread to sleep for at
1244** least the number of microseconds given.  ^The xCurrentTime()
1245** method returns a Julian Day Number for the current date and time as
1246** a floating point value.
1247** ^The xCurrentTimeInt64() method returns, as an integer, the Julian
1248** Day Number multiplied by 86400000 (the number of milliseconds in
1249** a 24-hour day).
1250** ^SQLite will use the xCurrentTimeInt64() method to get the current
1251** date and time if that method is available (if iVersion is 2 or
1252** greater and the function pointer is not NULL) and will fall back
1253** to xCurrentTime() if xCurrentTimeInt64() is unavailable.
1254**
1255** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
1256** are not used by the SQLite core.  These optional interfaces are provided
1257** by some VFSes to facilitate testing of the VFS code. By overriding
1258** system calls with functions under its control, a test program can
1259** simulate faults and error conditions that would otherwise be difficult
1260** or impossible to induce.  The set of system calls that can be overridden
1261** varies from one VFS to another, and from one version of the same VFS to the
1262** next.  Applications that use these interfaces must be prepared for any
1263** or all of these interfaces to be NULL or for their behavior to change
1264** from one release to the next.  Applications must not attempt to access
1265** any of these methods if the iVersion of the VFS is less than 3.
1266*/
1267typedef struct sqlite3_vfs sqlite3_vfs;
1268typedef void (*sqlite3_syscall_ptr)(void);
1269struct sqlite3_vfs {
1270  int iVersion;            /* Structure version number (currently 3) */
1271  int szOsFile;            /* Size of subclassed sqlite3_file */
1272  int mxPathname;          /* Maximum file pathname length */
1273  sqlite3_vfs *pNext;      /* Next registered VFS */
1274  const char *zName;       /* Name of this virtual file system */
1275  void *pAppData;          /* Pointer to application-specific data */
1276  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1277               int flags, int *pOutFlags);
1278  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1279  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1280  int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1281  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
1282  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1283  void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
1284  void (*xDlClose)(sqlite3_vfs*, void*);
1285  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
1286  int (*xSleep)(sqlite3_vfs*, int microseconds);
1287  int (*xCurrentTime)(sqlite3_vfs*, double*);
1288  int (*xGetLastError)(sqlite3_vfs*, int, char *);
1289  /*
1290  ** The methods above are in version 1 of the sqlite_vfs object
1291  ** definition.  Those that follow are added in version 2 or later
1292  */
1293  int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
1294  /*
1295  ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
1296  ** Those below are for version 3 and greater.
1297  */
1298  int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1299  sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1300  const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
1301  /*
1302  ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
1303  ** New fields may be appended in figure versions.  The iVersion
1304  ** value will increment whenever this happens.
1305  */
1306};
1307
1308/*
1309** CAPI3REF: Flags for the xAccess VFS method
1310**
1311** These integer constants can be used as the third parameter to
1312** the xAccess method of an [sqlite3_vfs] object.  They determine
1313** what kind of permissions the xAccess method is looking for.
1314** With SQLITE_ACCESS_EXISTS, the xAccess method
1315** simply checks whether the file exists.
1316** With SQLITE_ACCESS_READWRITE, the xAccess method
1317** checks whether the named directory is both readable and writable
1318** (in other words, if files can be added, removed, and renamed within
1319** the directory).
1320** The SQLITE_ACCESS_READWRITE constant is currently used only by the
1321** [temp_store_directory pragma], though this could change in a future
1322** release of SQLite.
1323** With SQLITE_ACCESS_READ, the xAccess method
1324** checks whether the file is readable.  The SQLITE_ACCESS_READ constant is
1325** currently unused, though it might be used in a future release of
1326** SQLite.
1327*/
1328#define SQLITE_ACCESS_EXISTS    0
1329#define SQLITE_ACCESS_READWRITE 1   /* Used by PRAGMA temp_store_directory */
1330#define SQLITE_ACCESS_READ      2   /* Unused */
1331
1332/*
1333** CAPI3REF: Flags for the xShmLock VFS method
1334**
1335** These integer constants define the various locking operations
1336** allowed by the xShmLock method of [sqlite3_io_methods].  The
1337** following are the only legal combinations of flags to the
1338** xShmLock method:
1339**
1340** <ul>
1341** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
1342** <li>  SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
1343** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
1344** <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
1345** </ul>
1346**
1347** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1348** was given no the corresponding lock.
1349**
1350** The xShmLock method can transition between unlocked and SHARED or
1351** between unlocked and EXCLUSIVE.  It cannot transition between SHARED
1352** and EXCLUSIVE.
1353*/
1354#define SQLITE_SHM_UNLOCK       1
1355#define SQLITE_SHM_LOCK         2
1356#define SQLITE_SHM_SHARED       4
1357#define SQLITE_SHM_EXCLUSIVE    8
1358
1359/*
1360** CAPI3REF: Maximum xShmLock index
1361**
1362** The xShmLock method on [sqlite3_io_methods] may use values
1363** between 0 and this upper bound as its "offset" argument.
1364** The SQLite core will never attempt to acquire or release a
1365** lock outside of this range
1366*/
1367#define SQLITE_SHM_NLOCK        8
1368
1369
1370/*
1371** CAPI3REF: Initialize The SQLite Library
1372**
1373** ^The sqlite3_initialize() routine initializes the
1374** SQLite library.  ^The sqlite3_shutdown() routine
1375** deallocates any resources that were allocated by sqlite3_initialize().
1376** These routines are designed to aid in process initialization and
1377** shutdown on embedded systems.  Workstation applications using
1378** SQLite normally do not need to invoke either of these routines.
1379**
1380** A call to sqlite3_initialize() is an "effective" call if it is
1381** the first time sqlite3_initialize() is invoked during the lifetime of
1382** the process, or if it is the first time sqlite3_initialize() is invoked
1383** following a call to sqlite3_shutdown().  ^(Only an effective call
1384** of sqlite3_initialize() does any initialization.  All other calls
1385** are harmless no-ops.)^
1386**
1387** A call to sqlite3_shutdown() is an "effective" call if it is the first
1388** call to sqlite3_shutdown() since the last sqlite3_initialize().  ^(Only
1389** an effective call to sqlite3_shutdown() does any deinitialization.
1390** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
1391**
1392** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()
1393** is not.  The sqlite3_shutdown() interface must only be called from a
1394** single thread.  All open [database connections] must be closed and all
1395** other SQLite resources must be deallocated prior to invoking
1396** sqlite3_shutdown().
1397**
1398** Among other things, ^sqlite3_initialize() will invoke
1399** sqlite3_os_init().  Similarly, ^sqlite3_shutdown()
1400** will invoke sqlite3_os_end().
1401**
1402** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1403** ^If for some reason, sqlite3_initialize() is unable to initialize
1404** the library (perhaps it is unable to allocate a needed resource such
1405** as a mutex) it returns an [error code] other than [SQLITE_OK].
1406**
1407** ^The sqlite3_initialize() routine is called internally by many other
1408** SQLite interfaces so that an application usually does not need to
1409** invoke sqlite3_initialize() directly.  For example, [sqlite3_open()]
1410** calls sqlite3_initialize() so the SQLite library will be automatically
1411** initialized when [sqlite3_open()] is called if it has not be initialized
1412** already.  ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
1413** compile-time option, then the automatic calls to sqlite3_initialize()
1414** are omitted and the application must call sqlite3_initialize() directly
1415** prior to using any other SQLite interface.  For maximum portability,
1416** it is recommended that applications always invoke sqlite3_initialize()
1417** directly prior to using any other SQLite interface.  Future releases
1418** of SQLite may require this.  In other words, the behavior exhibited
1419** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the
1420** default behavior in some future release of SQLite.
1421**
1422** The sqlite3_os_init() routine does operating-system specific
1423** initialization of the SQLite library.  The sqlite3_os_end()
1424** routine undoes the effect of sqlite3_os_init().  Typical tasks
1425** performed by these routines include allocation or deallocation
1426** of static resources, initialization of global variables,
1427** setting up a default [sqlite3_vfs] module, or setting up
1428** a default configuration using [sqlite3_config()].
1429**
1430** The application should never invoke either sqlite3_os_init()
1431** or sqlite3_os_end() directly.  The application should only invoke
1432** sqlite3_initialize() and sqlite3_shutdown().  The sqlite3_os_init()
1433** interface is called automatically by sqlite3_initialize() and
1434** sqlite3_os_end() is called by sqlite3_shutdown().  Appropriate
1435** implementations for sqlite3_os_init() and sqlite3_os_end()
1436** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
1437** When [custom builds | built for other platforms]
1438** (using the [SQLITE_OS_OTHER=1] compile-time
1439** option) the application must supply a suitable implementation for
1440** sqlite3_os_init() and sqlite3_os_end().  An application-supplied
1441** implementation of sqlite3_os_init() or sqlite3_os_end()
1442** must return [SQLITE_OK] on success and some other [error code] upon
1443** failure.
1444*/
1445SQLITE_API int sqlite3_initialize(void);
1446SQLITE_API int sqlite3_shutdown(void);
1447SQLITE_API int sqlite3_os_init(void);
1448SQLITE_API int sqlite3_os_end(void);
1449
1450/*
1451** CAPI3REF: Configuring The SQLite Library
1452**
1453** The sqlite3_config() interface is used to make global configuration
1454** changes to SQLite in order to tune SQLite to the specific needs of
1455** the application.  The default configuration is recommended for most
1456** applications and so this routine is usually not necessary.  It is
1457** provided to support rare applications with unusual needs.
1458**
1459** The sqlite3_config() interface is not threadsafe.  The application
1460** must insure that no other SQLite interfaces are invoked by other
1461** threads while sqlite3_config() is running.  Furthermore, sqlite3_config()
1462** may only be invoked prior to library initialization using
1463** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
1464** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
1465** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
1466** Note, however, that ^sqlite3_config() can be called as part of the
1467** implementation of an application-defined [sqlite3_os_init()].
1468**
1469** The first argument to sqlite3_config() is an integer
1470** [configuration option] that determines
1471** what property of SQLite is to be configured.  Subsequent arguments
1472** vary depending on the [configuration option]
1473** in the first argument.
1474**
1475** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
1476** ^If the option is unknown or SQLite is unable to set the option
1477** then this routine returns a non-zero [error code].
1478*/
1479SQLITE_API int sqlite3_config(int, ...);
1480
1481/*
1482** CAPI3REF: Configure database connections
1483**
1484** The sqlite3_db_config() interface is used to make configuration
1485** changes to a [database connection].  The interface is similar to
1486** [sqlite3_config()] except that the changes apply to a single
1487** [database connection] (specified in the first argument).
1488**
1489** The second argument to sqlite3_db_config(D,V,...)  is the
1490** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
1491** that indicates what aspect of the [database connection] is being configured.
1492** Subsequent arguments vary depending on the configuration verb.
1493**
1494** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
1495** the call is considered successful.
1496*/
1497SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
1498
1499/*
1500** CAPI3REF: Memory Allocation Routines
1501**
1502** An instance of this object defines the interface between SQLite
1503** and low-level memory allocation routines.
1504**
1505** This object is used in only one place in the SQLite interface.
1506** A pointer to an instance of this object is the argument to
1507** [sqlite3_config()] when the configuration option is
1508** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
1509** By creating an instance of this object
1510** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
1511** during configuration, an application can specify an alternative
1512** memory allocation subsystem for SQLite to use for all of its
1513** dynamic memory needs.
1514**
1515** Note that SQLite comes with several [built-in memory allocators]
1516** that are perfectly adequate for the overwhelming majority of applications
1517** and that this object is only useful to a tiny minority of applications
1518** with specialized memory allocation requirements.  This object is
1519** also used during testing of SQLite in order to specify an alternative
1520** memory allocator that simulates memory out-of-memory conditions in
1521** order to verify that SQLite recovers gracefully from such
1522** conditions.
1523**
1524** The xMalloc, xRealloc, and xFree methods must work like the
1525** malloc(), realloc() and free() functions from the standard C library.
1526** ^SQLite guarantees that the second argument to
1527** xRealloc is always a value returned by a prior call to xRoundup.
1528**
1529** xSize should return the allocated size of a memory allocation
1530** previously obtained from xMalloc or xRealloc.  The allocated size
1531** is always at least as big as the requested size but may be larger.
1532**
1533** The xRoundup method returns what would be the allocated size of
1534** a memory allocation given a particular requested size.  Most memory
1535** allocators round up memory allocations at least to the next multiple
1536** of 8.  Some allocators round up to a larger multiple or to a power of 2.
1537** Every memory allocation request coming in through [sqlite3_malloc()]
1538** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
1539** that causes the corresponding memory allocation to fail.
1540**
1541** The xInit method initializes the memory allocator.  For example,
1542** it might allocate any require mutexes or initialize internal data
1543** structures.  The xShutdown method is invoked (indirectly) by
1544** [sqlite3_shutdown()] and should deallocate any resources acquired
1545** by xInit.  The pAppData pointer is used as the only parameter to
1546** xInit and xShutdown.
1547**
1548** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
1549** the xInit method, so the xInit method need not be threadsafe.  The
1550** xShutdown method is only called from [sqlite3_shutdown()] so it does
1551** not need to be threadsafe either.  For all other methods, SQLite
1552** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
1553** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
1554** it is by default) and so the methods are automatically serialized.
1555** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
1556** methods must be threadsafe or else make their own arrangements for
1557** serialization.
1558**
1559** SQLite will never invoke xInit() more than once without an intervening
1560** call to xShutdown().
1561*/
1562typedef struct sqlite3_mem_methods sqlite3_mem_methods;
1563struct sqlite3_mem_methods {
1564  void *(*xMalloc)(int);         /* Memory allocation function */
1565  void (*xFree)(void*);          /* Free a prior allocation */
1566  void *(*xRealloc)(void*,int);  /* Resize an allocation */
1567  int (*xSize)(void*);           /* Return the size of an allocation */
1568  int (*xRoundup)(int);          /* Round up request size to allocation size */
1569  int (*xInit)(void*);           /* Initialize the memory allocator */
1570  void (*xShutdown)(void*);      /* Deinitialize the memory allocator */
1571  void *pAppData;                /* Argument to xInit() and xShutdown() */
1572};
1573
1574/*
1575** CAPI3REF: Configuration Options
1576** KEYWORDS: {configuration option}
1577**
1578** These constants are the available integer configuration options that
1579** can be passed as the first argument to the [sqlite3_config()] interface.
1580**
1581** New configuration options may be added in future releases of SQLite.
1582** Existing configuration options might be discontinued.  Applications
1583** should check the return code from [sqlite3_config()] to make sure that
1584** the call worked.  The [sqlite3_config()] interface will return a
1585** non-zero [error code] if a discontinued or unsupported configuration option
1586** is invoked.
1587**
1588** <dl>
1589** [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
1590** <dd>There are no arguments to this option.  ^This option sets the
1591** [threading mode] to Single-thread.  In other words, it disables
1592** all mutexing and puts SQLite into a mode where it can only be used
1593** by a single thread.   ^If SQLite is compiled with
1594** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1595** it is not possible to change the [threading mode] from its default
1596** value of Single-thread and so [sqlite3_config()] will return
1597** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD
1598** configuration option.</dd>
1599**
1600** [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
1601** <dd>There are no arguments to this option.  ^This option sets the
1602** [threading mode] to Multi-thread.  In other words, it disables
1603** mutexing on [database connection] and [prepared statement] objects.
1604** The application is responsible for serializing access to
1605** [database connections] and [prepared statements].  But other mutexes
1606** are enabled so that SQLite will be safe to use in a multi-threaded
1607** environment as long as no two threads attempt to use the same
1608** [database connection] at the same time.  ^If SQLite is compiled with
1609** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1610** it is not possible to set the Multi-thread [threading mode] and
1611** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1612** SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
1613**
1614** [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
1615** <dd>There are no arguments to this option.  ^This option sets the
1616** [threading mode] to Serialized. In other words, this option enables
1617** all mutexes including the recursive
1618** mutexes on [database connection] and [prepared statement] objects.
1619** In this mode (which is the default when SQLite is compiled with
1620** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
1621** to [database connections] and [prepared statements] so that the
1622** application is free to use the same [database connection] or the
1623** same [prepared statement] in different threads at the same time.
1624** ^If SQLite is compiled with
1625** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1626** it is not possible to set the Serialized [threading mode] and
1627** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1628** SQLITE_CONFIG_SERIALIZED configuration option.</dd>
1629**
1630** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
1631** <dd> ^(This option takes a single argument which is a pointer to an
1632** instance of the [sqlite3_mem_methods] structure.  The argument specifies
1633** alternative low-level memory allocation routines to be used in place of
1634** the memory allocation routines built into SQLite.)^ ^SQLite makes
1635** its own private copy of the content of the [sqlite3_mem_methods] structure
1636** before the [sqlite3_config()] call returns.</dd>
1637**
1638** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
1639** <dd> ^(This option takes a single argument which is a pointer to an
1640** instance of the [sqlite3_mem_methods] structure.  The [sqlite3_mem_methods]
1641** structure is filled with the currently defined memory allocation routines.)^
1642** This option can be used to overload the default memory allocation
1643** routines with a wrapper that simulations memory allocation failure or
1644** tracks memory usage, for example. </dd>
1645**
1646** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
1647** <dd> ^This option takes single argument of type int, interpreted as a
1648** boolean, which enables or disables the collection of memory allocation
1649** statistics. ^(When memory allocation statistics are disabled, the
1650** following SQLite interfaces become non-operational:
1651**   <ul>
1652**   <li> [sqlite3_memory_used()]
1653**   <li> [sqlite3_memory_highwater()]
1654**   <li> [sqlite3_soft_heap_limit64()]
1655**   <li> [sqlite3_status()]
1656**   </ul>)^
1657** ^Memory allocation statistics are enabled by default unless SQLite is
1658** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
1659** allocation statistics are disabled by default.
1660** </dd>
1661**
1662** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
1663** <dd> ^This option specifies a static memory buffer that SQLite can use for
1664** scratch memory.  There are three arguments:  A pointer an 8-byte
1665** aligned memory buffer from which the scratch allocations will be
1666** drawn, the size of each scratch allocation (sz),
1667** and the maximum number of scratch allocations (N).  The sz
1668** argument must be a multiple of 16.
1669** The first argument must be a pointer to an 8-byte aligned buffer
1670** of at least sz*N bytes of memory.
1671** ^SQLite will use no more than two scratch buffers per thread.  So
1672** N should be set to twice the expected maximum number of threads.
1673** ^SQLite will never require a scratch buffer that is more than 6
1674** times the database page size. ^If SQLite needs needs additional
1675** scratch memory beyond what is provided by this configuration option, then
1676** [sqlite3_malloc()] will be used to obtain the memory needed.</dd>
1677**
1678** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
1679** <dd> ^This option specifies a static memory buffer that SQLite can use for
1680** the database page cache with the default page cache implementation.
1681** This configuration should not be used if an application-define page
1682** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2 option.
1683** There are three arguments to this option: A pointer to 8-byte aligned
1684** memory, the size of each page buffer (sz), and the number of pages (N).
1685** The sz argument should be the size of the largest database page
1686** (a power of two between 512 and 32768) plus a little extra for each
1687** page header.  ^The page header size is 20 to 40 bytes depending on
1688** the host architecture.  ^It is harmless, apart from the wasted memory,
1689** to make sz a little too large.  The first
1690** argument should point to an allocation of at least sz*N bytes of memory.
1691** ^SQLite will use the memory provided by the first argument to satisfy its
1692** memory needs for the first N pages that it adds to cache.  ^If additional
1693** page cache memory is needed beyond what is provided by this option, then
1694** SQLite goes to [sqlite3_malloc()] for the additional storage space.
1695** The pointer in the first argument must
1696** be aligned to an 8-byte boundary or subsequent behavior of SQLite
1697** will be undefined.</dd>
1698**
1699** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
1700** <dd> ^This option specifies a static memory buffer that SQLite will use
1701** for all of its dynamic memory allocation needs beyond those provided
1702** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].
1703** There are three arguments: An 8-byte aligned pointer to the memory,
1704** the number of bytes in the memory buffer, and the minimum allocation size.
1705** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
1706** to using its default memory allocator (the system malloc() implementation),
1707** undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  ^If the
1708** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
1709** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
1710** allocator is engaged to handle all of SQLites memory allocation needs.
1711** The first pointer (the memory pointer) must be aligned to an 8-byte
1712** boundary or subsequent behavior of SQLite will be undefined.
1713** The minimum allocation size is capped at 2**12. Reasonable values
1714** for the minimum allocation size are 2**5 through 2**8.</dd>
1715**
1716** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
1717** <dd> ^(This option takes a single argument which is a pointer to an
1718** instance of the [sqlite3_mutex_methods] structure.  The argument specifies
1719** alternative low-level mutex routines to be used in place
1720** the mutex routines built into SQLite.)^  ^SQLite makes a copy of the
1721** content of the [sqlite3_mutex_methods] structure before the call to
1722** [sqlite3_config()] returns. ^If SQLite is compiled with
1723** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1724** the entire mutexing subsystem is omitted from the build and hence calls to
1725** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
1726** return [SQLITE_ERROR].</dd>
1727**
1728** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
1729** <dd> ^(This option takes a single argument which is a pointer to an
1730** instance of the [sqlite3_mutex_methods] structure.  The
1731** [sqlite3_mutex_methods]
1732** structure is filled with the currently defined mutex routines.)^
1733** This option can be used to overload the default mutex allocation
1734** routines with a wrapper used to track mutex usage for performance
1735** profiling or testing, for example.   ^If SQLite is compiled with
1736** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1737** the entire mutexing subsystem is omitted from the build and hence calls to
1738** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
1739** return [SQLITE_ERROR].</dd>
1740**
1741** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
1742** <dd> ^(This option takes two arguments that determine the default
1743** memory allocation for the lookaside memory allocator on each
1744** [database connection].  The first argument is the
1745** size of each lookaside buffer slot and the second is the number of
1746** slots allocated to each database connection.)^  ^(This option sets the
1747** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
1748** verb to [sqlite3_db_config()] can be used to change the lookaside
1749** configuration on individual connections.)^ </dd>
1750**
1751** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
1752** <dd> ^(This option takes a single argument which is a pointer to
1753** an [sqlite3_pcache_methods2] object.  This object specifies the interface
1754** to a custom page cache implementation.)^  ^SQLite makes a copy of the
1755** object and uses it for page cache memory allocations.</dd>
1756**
1757** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
1758** <dd> ^(This option takes a single argument which is a pointer to an
1759** [sqlite3_pcache_methods2] object.  SQLite copies of the current
1760** page cache implementation into that object.)^ </dd>
1761**
1762** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
1763** <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite
1764** global [error log].
1765** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a
1766** function with a call signature of void(*)(void*,int,const char*),
1767** and a pointer to void. ^If the function pointer is not NULL, it is
1768** invoked by [sqlite3_log()] to process each logging event.  ^If the
1769** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
1770** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is
1771** passed through as the first parameter to the application-defined logger
1772** function whenever that function is invoked.  ^The second parameter to
1773** the logger function is a copy of the first parameter to the corresponding
1774** [sqlite3_log()] call and is intended to be a [result code] or an
1775** [extended result code].  ^The third parameter passed to the logger is
1776** log message after formatting via [sqlite3_snprintf()].
1777** The SQLite logging interface is not reentrant; the logger function
1778** supplied by the application must not invoke any SQLite interface.
1779** In a multi-threaded application, the application-defined logger
1780** function must be threadsafe. </dd>
1781**
1782** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
1783** <dd>^(This option takes a single argument of type int. If non-zero, then
1784** URI handling is globally enabled. If the parameter is zero, then URI handling
1785** is globally disabled.)^ ^If URI handling is globally enabled, all filenames
1786** passed to [sqlite3_open()], [sqlite3_open_v2()], [sqlite3_open16()] or
1787** specified as part of [ATTACH] commands are interpreted as URIs, regardless
1788** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
1789** connection is opened. ^If it is globally disabled, filenames are
1790** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
1791** database connection is opened. ^(By default, URI handling is globally
1792** disabled. The default value may be changed by compiling with the
1793** [SQLITE_USE_URI] symbol defined.)^
1794**
1795** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]] <dt>SQLITE_CONFIG_COVERING_INDEX_SCAN
1796** <dd>^This option takes a single integer argument which is interpreted as
1797** a boolean in order to enable or disable the use of covering indices for
1798** full table scans in the query optimizer.  ^The default setting is determined
1799** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
1800** if that compile-time option is omitted.
1801** The ability to disable the use of covering indices for full table scans
1802** is because some incorrectly coded legacy applications might malfunction
1803** when the optimization is enabled.  Providing the ability to
1804** disable the optimization allows the older, buggy application code to work
1805** without change even with newer versions of SQLite.
1806**
1807** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]
1808** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE
1809** <dd> These options are obsolete and should not be used by new code.
1810** They are retained for backwards compatibility but are now no-ops.
1811** </dd>
1812**
1813** [[SQLITE_CONFIG_SQLLOG]]
1814** <dt>SQLITE_CONFIG_SQLLOG
1815** <dd>This option is only available if sqlite is compiled with the
1816** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
1817** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int).
1818** The second should be of type (void*). The callback is invoked by the library
1819** in three separate circumstances, identified by the value passed as the
1820** fourth parameter. If the fourth parameter is 0, then the database connection
1821** passed as the second argument has just been opened. The third argument
1822** points to a buffer containing the name of the main database file. If the
1823** fourth parameter is 1, then the SQL statement that the third parameter
1824** points to has just been executed. Or, if the fourth parameter is 2, then
1825** the connection being passed as the second parameter is being closed. The
1826** third parameter is passed NULL In this case.  An example of using this
1827** configuration option can be seen in the "test_sqllog.c" source file in
1828** the canonical SQLite source tree.</dd>
1829**
1830** [[SQLITE_CONFIG_MMAP_SIZE]]
1831** <dt>SQLITE_CONFIG_MMAP_SIZE
1832** <dd>^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values
1833** that are the default mmap size limit (the default setting for
1834** [PRAGMA mmap_size]) and the maximum allowed mmap size limit.
1835** ^The default setting can be overridden by each database connection using
1836** either the [PRAGMA mmap_size] command, or by using the
1837** [SQLITE_FCNTL_MMAP_SIZE] file control.  ^(The maximum allowed mmap size
1838** cannot be changed at run-time.  Nor may the maximum allowed mmap size
1839** exceed the compile-time maximum mmap size set by the
1840** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
1841** ^If either argument to this option is negative, then that argument is
1842** changed to its compile-time default.
1843**
1844** [[SQLITE_CONFIG_WIN32_HEAPSIZE]]
1845** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
1846** <dd>^This option is only available if SQLite is compiled for Windows
1847** with the [SQLITE_WIN32_MALLOC] pre-processor macro defined.
1848** SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
1849** that specifies the maximum size of the created heap.
1850** </dl>
1851*/
1852#define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
1853#define SQLITE_CONFIG_MULTITHREAD   2  /* nil */
1854#define SQLITE_CONFIG_SERIALIZED    3  /* nil */
1855#define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */
1856#define SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */
1857#define SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */
1858#define SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */
1859#define SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */
1860#define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */
1861#define SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */
1862#define SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */
1863/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
1864#define SQLITE_CONFIG_LOOKASIDE    13  /* int int */
1865#define SQLITE_CONFIG_PCACHE       14  /* no-op */
1866#define SQLITE_CONFIG_GETPCACHE    15  /* no-op */
1867#define SQLITE_CONFIG_LOG          16  /* xFunc, void* */
1868#define SQLITE_CONFIG_URI          17  /* int */
1869#define SQLITE_CONFIG_PCACHE2      18  /* sqlite3_pcache_methods2* */
1870#define SQLITE_CONFIG_GETPCACHE2   19  /* sqlite3_pcache_methods2* */
1871#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
1872#define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */
1873#define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */
1874#define SQLITE_CONFIG_WIN32_HEAPSIZE      23  /* int nByte */
1875
1876/*
1877** CAPI3REF: Database Connection Configuration Options
1878**
1879** These constants are the available integer configuration options that
1880** can be passed as the second argument to the [sqlite3_db_config()] interface.
1881**
1882** New configuration options may be added in future releases of SQLite.
1883** Existing configuration options might be discontinued.  Applications
1884** should check the return code from [sqlite3_db_config()] to make sure that
1885** the call worked.  ^The [sqlite3_db_config()] interface will return a
1886** non-zero [error code] if a discontinued or unsupported configuration option
1887** is invoked.
1888**
1889** <dl>
1890** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
1891** <dd> ^This option takes three additional arguments that determine the
1892** [lookaside memory allocator] configuration for the [database connection].
1893** ^The first argument (the third parameter to [sqlite3_db_config()] is a
1894** pointer to a memory buffer to use for lookaside memory.
1895** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
1896** may be NULL in which case SQLite will allocate the
1897** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
1898** size of each lookaside buffer slot.  ^The third argument is the number of
1899** slots.  The size of the buffer in the first argument must be greater than
1900** or equal to the product of the second and third arguments.  The buffer
1901** must be aligned to an 8-byte boundary.  ^If the second argument to
1902** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
1903** rounded down to the next smaller multiple of 8.  ^(The lookaside memory
1904** configuration for a database connection can only be changed when that
1905** connection is not currently using lookaside memory, or in other words
1906** when the "current value" returned by
1907** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.
1908** Any attempt to change the lookaside memory configuration when lookaside
1909** memory is in use leaves the configuration unchanged and returns
1910** [SQLITE_BUSY].)^</dd>
1911**
1912** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
1913** <dd> ^This option is used to enable or disable the enforcement of
1914** [foreign key constraints].  There should be two additional arguments.
1915** The first argument is an integer which is 0 to disable FK enforcement,
1916** positive to enable FK enforcement or negative to leave FK enforcement
1917** unchanged.  The second parameter is a pointer to an integer into which
1918** is written 0 or 1 to indicate whether FK enforcement is off or on
1919** following this call.  The second parameter may be a NULL pointer, in
1920** which case the FK enforcement setting is not reported back. </dd>
1921**
1922** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
1923** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
1924** There should be two additional arguments.
1925** The first argument is an integer which is 0 to disable triggers,
1926** positive to enable triggers or negative to leave the setting unchanged.
1927** The second parameter is a pointer to an integer into which
1928** is written 0 or 1 to indicate whether triggers are disabled or enabled
1929** following this call.  The second parameter may be a NULL pointer, in
1930** which case the trigger setting is not reported back. </dd>
1931**
1932** </dl>
1933*/
1934#define SQLITE_DBCONFIG_LOOKASIDE       1001  /* void* int int */
1935#define SQLITE_DBCONFIG_ENABLE_FKEY     1002  /* int int* */
1936#define SQLITE_DBCONFIG_ENABLE_TRIGGER  1003  /* int int* */
1937
1938
1939/*
1940** CAPI3REF: Enable Or Disable Extended Result Codes
1941**
1942** ^The sqlite3_extended_result_codes() routine enables or disables the
1943** [extended result codes] feature of SQLite. ^The extended result
1944** codes are disabled by default for historical compatibility.
1945*/
1946SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
1947
1948/*
1949** CAPI3REF: Last Insert Rowid
1950**
1951** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables)
1952** has a unique 64-bit signed
1953** integer key called the [ROWID | "rowid"]. ^The rowid is always available
1954** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
1955** names are not also used by explicitly declared columns. ^If
1956** the table has a column of type [INTEGER PRIMARY KEY] then that column
1957** is another alias for the rowid.
1958**
1959** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
1960** most recent successful [INSERT] into a rowid table or [virtual table]
1961** on database connection D.
1962** ^Inserts into [WITHOUT ROWID] tables are not recorded.
1963** ^If no successful [INSERT]s into rowid tables
1964** have ever occurred on the database connection D,
1965** then sqlite3_last_insert_rowid(D) returns zero.
1966**
1967** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
1968** method, then this routine will return the [rowid] of the inserted
1969** row as long as the trigger or virtual table method is running.
1970** But once the trigger or virtual table method ends, the value returned
1971** by this routine reverts to what it was before the trigger or virtual
1972** table method began.)^
1973**
1974** ^An [INSERT] that fails due to a constraint violation is not a
1975** successful [INSERT] and does not change the value returned by this
1976** routine.  ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
1977** and INSERT OR ABORT make no changes to the return value of this
1978** routine when their insertion fails.  ^(When INSERT OR REPLACE
1979** encounters a constraint violation, it does not fail.  The
1980** INSERT continues to completion after deleting rows that caused
1981** the constraint problem so INSERT OR REPLACE will always change
1982** the return value of this interface.)^
1983**
1984** ^For the purposes of this routine, an [INSERT] is considered to
1985** be successful even if it is subsequently rolled back.
1986**
1987** This function is accessible to SQL statements via the
1988** [last_insert_rowid() SQL function].
1989**
1990** If a separate thread performs a new [INSERT] on the same
1991** database connection while the [sqlite3_last_insert_rowid()]
1992** function is running and thus changes the last insert [rowid],
1993** then the value returned by [sqlite3_last_insert_rowid()] is
1994** unpredictable and might not equal either the old or the new
1995** last insert [rowid].
1996*/
1997SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
1998
1999/*
2000** CAPI3REF: Count The Number Of Rows Modified
2001**
2002** ^This function returns the number of database rows that were changed
2003** or inserted or deleted by the most recently completed SQL statement
2004** on the [database connection] specified by the first parameter.
2005** ^(Only changes that are directly specified by the [INSERT], [UPDATE],
2006** or [DELETE] statement are counted.  Auxiliary changes caused by
2007** triggers or [foreign key actions] are not counted.)^ Use the
2008** [sqlite3_total_changes()] function to find the total number of changes
2009** including changes caused by triggers and foreign key actions.
2010**
2011** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
2012** are not counted.  Only real table changes are counted.
2013**
2014** ^(A "row change" is a change to a single row of a single table
2015** caused by an INSERT, DELETE, or UPDATE statement.  Rows that
2016** are changed as side effects of [REPLACE] constraint resolution,
2017** rollback, ABORT processing, [DROP TABLE], or by any other
2018** mechanisms do not count as direct row changes.)^
2019**
2020** A "trigger context" is a scope of execution that begins and
2021** ends with the script of a [CREATE TRIGGER | trigger].
2022** Most SQL statements are
2023** evaluated outside of any trigger.  This is the "top level"
2024** trigger context.  If a trigger fires from the top level, a
2025** new trigger context is entered for the duration of that one
2026** trigger.  Subtriggers create subcontexts for their duration.
2027**
2028** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
2029** not create a new trigger context.
2030**
2031** ^This function returns the number of direct row changes in the
2032** most recent INSERT, UPDATE, or DELETE statement within the same
2033** trigger context.
2034**
2035** ^Thus, when called from the top level, this function returns the
2036** number of changes in the most recent INSERT, UPDATE, or DELETE
2037** that also occurred at the top level.  ^(Within the body of a trigger,
2038** the sqlite3_changes() interface can be called to find the number of
2039** changes in the most recently completed INSERT, UPDATE, or DELETE
2040** statement within the body of the same trigger.
2041** However, the number returned does not include changes
2042** caused by subtriggers since those have their own context.)^
2043**
2044** See also the [sqlite3_total_changes()] interface, the
2045** [count_changes pragma], and the [changes() SQL function].
2046**
2047** If a separate thread makes changes on the same database connection
2048** while [sqlite3_changes()] is running then the value returned
2049** is unpredictable and not meaningful.
2050*/
2051SQLITE_API int sqlite3_changes(sqlite3*);
2052
2053/*
2054** CAPI3REF: Total Number Of Rows Modified
2055**
2056** ^This function returns the number of row changes caused by [INSERT],
2057** [UPDATE] or [DELETE] statements since the [database connection] was opened.
2058** ^(The count returned by sqlite3_total_changes() includes all changes
2059** from all [CREATE TRIGGER | trigger] contexts and changes made by
2060** [foreign key actions]. However,
2061** the count does not include changes used to implement [REPLACE] constraints,
2062** do rollbacks or ABORT processing, or [DROP TABLE] processing.  The
2063** count does not include rows of views that fire an [INSTEAD OF trigger],
2064** though if the INSTEAD OF trigger makes changes of its own, those changes
2065** are counted.)^
2066** ^The sqlite3_total_changes() function counts the changes as soon as
2067** the statement that makes them is completed (when the statement handle
2068** is passed to [sqlite3_reset()] or [sqlite3_finalize()]).
2069**
2070** See also the [sqlite3_changes()] interface, the
2071** [count_changes pragma], and the [total_changes() SQL function].
2072**
2073** If a separate thread makes changes on the same database connection
2074** while [sqlite3_total_changes()] is running then the value
2075** returned is unpredictable and not meaningful.
2076*/
2077SQLITE_API int sqlite3_total_changes(sqlite3*);
2078
2079/*
2080** CAPI3REF: Interrupt A Long-Running Query
2081**
2082** ^This function causes any pending database operation to abort and
2083** return at its earliest opportunity. This routine is typically
2084** called in response to a user action such as pressing "Cancel"
2085** or Ctrl-C where the user wants a long query operation to halt
2086** immediately.
2087**
2088** ^It is safe to call this routine from a thread different from the
2089** thread that is currently running the database operation.  But it
2090** is not safe to call this routine with a [database connection] that
2091** is closed or might close before sqlite3_interrupt() returns.
2092**
2093** ^If an SQL operation is very nearly finished at the time when
2094** sqlite3_interrupt() is called, then it might not have an opportunity
2095** to be interrupted and might continue to completion.
2096**
2097** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
2098** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
2099** that is inside an explicit transaction, then the entire transaction
2100** will be rolled back automatically.
2101**
2102** ^The sqlite3_interrupt(D) call is in effect until all currently running
2103** SQL statements on [database connection] D complete.  ^Any new SQL statements
2104** that are started after the sqlite3_interrupt() call and before the
2105** running statements reaches zero are interrupted as if they had been
2106** running prior to the sqlite3_interrupt() call.  ^New SQL statements
2107** that are started after the running statement count reaches zero are
2108** not effected by the sqlite3_interrupt().
2109** ^A call to sqlite3_interrupt(D) that occurs when there are no running
2110** SQL statements is a no-op and has no effect on SQL statements
2111** that are started after the sqlite3_interrupt() call returns.
2112**
2113** If the database connection closes while [sqlite3_interrupt()]
2114** is running then bad things will likely happen.
2115*/
2116SQLITE_API void sqlite3_interrupt(sqlite3*);
2117
2118/*
2119** CAPI3REF: Determine If An SQL Statement Is Complete
2120**
2121** These routines are useful during command-line input to determine if the
2122** currently entered text seems to form a complete SQL statement or
2123** if additional input is needed before sending the text into
2124** SQLite for parsing.  ^These routines return 1 if the input string
2125** appears to be a complete SQL statement.  ^A statement is judged to be
2126** complete if it ends with a semicolon token and is not a prefix of a
2127** well-formed CREATE TRIGGER statement.  ^Semicolons that are embedded within
2128** string literals or quoted identifier names or comments are not
2129** independent tokens (they are part of the token in which they are
2130** embedded) and thus do not count as a statement terminator.  ^Whitespace
2131** and comments that follow the final semicolon are ignored.
2132**
2133** ^These routines return 0 if the statement is incomplete.  ^If a
2134** memory allocation fails, then SQLITE_NOMEM is returned.
2135**
2136** ^These routines do not parse the SQL statements thus
2137** will not detect syntactically incorrect SQL.
2138**
2139** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
2140** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
2141** automatically by sqlite3_complete16().  If that initialization fails,
2142** then the return value from sqlite3_complete16() will be non-zero
2143** regardless of whether or not the input SQL is complete.)^
2144**
2145** The input to [sqlite3_complete()] must be a zero-terminated
2146** UTF-8 string.
2147**
2148** The input to [sqlite3_complete16()] must be a zero-terminated
2149** UTF-16 string in native byte order.
2150*/
2151SQLITE_API int sqlite3_complete(const char *sql);
2152SQLITE_API int sqlite3_complete16(const void *sql);
2153
2154/*
2155** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
2156**
2157** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X
2158** that might be invoked with argument P whenever
2159** an attempt is made to access a database table associated with
2160** [database connection] D when another thread
2161** or process has the table locked.
2162** The sqlite3_busy_handler() interface is used to implement
2163** [sqlite3_busy_timeout()] and [PRAGMA busy_timeout].
2164**
2165** ^If the busy callback is NULL, then [SQLITE_BUSY]
2166** is returned immediately upon encountering the lock.  ^If the busy callback
2167** is not NULL, then the callback might be invoked with two arguments.
2168**
2169** ^The first argument to the busy handler is a copy of the void* pointer which
2170** is the third argument to sqlite3_busy_handler().  ^The second argument to
2171** the busy handler callback is the number of times that the busy handler has
2172** been invoked for the same locking event.  ^If the
2173** busy callback returns 0, then no additional attempts are made to
2174** access the database and [SQLITE_BUSY] is returned
2175** to the application.
2176** ^If the callback returns non-zero, then another attempt
2177** is made to access the database and the cycle repeats.
2178**
2179** The presence of a busy handler does not guarantee that it will be invoked
2180** when there is lock contention. ^If SQLite determines that invoking the busy
2181** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
2182** to the application instead of invoking the
2183** busy handler.
2184** Consider a scenario where one process is holding a read lock that
2185** it is trying to promote to a reserved lock and
2186** a second process is holding a reserved lock that it is trying
2187** to promote to an exclusive lock.  The first process cannot proceed
2188** because it is blocked by the second and the second process cannot
2189** proceed because it is blocked by the first.  If both processes
2190** invoke the busy handlers, neither will make any progress.  Therefore,
2191** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
2192** will induce the first process to release its read lock and allow
2193** the second process to proceed.
2194**
2195** ^The default busy callback is NULL.
2196**
2197** ^(There can only be a single busy handler defined for each
2198** [database connection].  Setting a new busy handler clears any
2199** previously set handler.)^  ^Note that calling [sqlite3_busy_timeout()]
2200** or evaluating [PRAGMA busy_timeout=N] will change the
2201** busy handler and thus clear any previously set busy handler.
2202**
2203** The busy callback should not take any actions which modify the
2204** database connection that invoked the busy handler.  In other words,
2205** the busy handler is not reentrant.  Any such actions
2206** result in undefined behavior.
2207**
2208** A busy handler must not close the database connection
2209** or [prepared statement] that invoked the busy handler.
2210*/
2211SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
2212
2213/*
2214** CAPI3REF: Set A Busy Timeout
2215**
2216** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
2217** for a specified amount of time when a table is locked.  ^The handler
2218** will sleep multiple times until at least "ms" milliseconds of sleeping
2219** have accumulated.  ^After at least "ms" milliseconds of sleeping,
2220** the handler returns 0 which causes [sqlite3_step()] to return
2221** [SQLITE_BUSY].
2222**
2223** ^Calling this routine with an argument less than or equal to zero
2224** turns off all busy handlers.
2225**
2226** ^(There can only be a single busy handler for a particular
2227** [database connection] at any given moment.  If another busy handler
2228** was defined  (using [sqlite3_busy_handler()]) prior to calling
2229** this routine, that other busy handler is cleared.)^
2230**
2231** See also:  [PRAGMA busy_timeout]
2232*/
2233SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
2234
2235/*
2236** CAPI3REF: Convenience Routines For Running Queries
2237**
2238** This is a legacy interface that is preserved for backwards compatibility.
2239** Use of this interface is not recommended.
2240**
2241** Definition: A <b>result table</b> is memory data structure created by the
2242** [sqlite3_get_table()] interface.  A result table records the
2243** complete query results from one or more queries.
2244**
2245** The table conceptually has a number of rows and columns.  But
2246** these numbers are not part of the result table itself.  These
2247** numbers are obtained separately.  Let N be the number of rows
2248** and M be the number of columns.
2249**
2250** A result table is an array of pointers to zero-terminated UTF-8 strings.
2251** There are (N+1)*M elements in the array.  The first M pointers point
2252** to zero-terminated strings that  contain the names of the columns.
2253** The remaining entries all point to query results.  NULL values result
2254** in NULL pointers.  All other values are in their UTF-8 zero-terminated
2255** string representation as returned by [sqlite3_column_text()].
2256**
2257** A result table might consist of one or more memory allocations.
2258** It is not safe to pass a result table directly to [sqlite3_free()].
2259** A result table should be deallocated using [sqlite3_free_table()].
2260**
2261** ^(As an example of the result table format, suppose a query result
2262** is as follows:
2263**
2264** <blockquote><pre>
2265**        Name        | Age
2266**        -----------------------
2267**        Alice       | 43
2268**        Bob         | 28
2269**        Cindy       | 21
2270** </pre></blockquote>
2271**
2272** There are two column (M==2) and three rows (N==3).  Thus the
2273** result table has 8 entries.  Suppose the result table is stored
2274** in an array names azResult.  Then azResult holds this content:
2275**
2276** <blockquote><pre>
2277**        azResult&#91;0] = "Name";
2278**        azResult&#91;1] = "Age";
2279**        azResult&#91;2] = "Alice";
2280**        azResult&#91;3] = "43";
2281**        azResult&#91;4] = "Bob";
2282**        azResult&#91;5] = "28";
2283**        azResult&#91;6] = "Cindy";
2284**        azResult&#91;7] = "21";
2285** </pre></blockquote>)^
2286**
2287** ^The sqlite3_get_table() function evaluates one or more
2288** semicolon-separated SQL statements in the zero-terminated UTF-8
2289** string of its 2nd parameter and returns a result table to the
2290** pointer given in its 3rd parameter.
2291**
2292** After the application has finished with the result from sqlite3_get_table(),
2293** it must pass the result table pointer to sqlite3_free_table() in order to
2294** release the memory that was malloced.  Because of the way the
2295** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
2296** function must not try to call [sqlite3_free()] directly.  Only
2297** [sqlite3_free_table()] is able to release the memory properly and safely.
2298**
2299** The sqlite3_get_table() interface is implemented as a wrapper around
2300** [sqlite3_exec()].  The sqlite3_get_table() routine does not have access
2301** to any internal data structures of SQLite.  It uses only the public
2302** interface defined here.  As a consequence, errors that occur in the
2303** wrapper layer outside of the internal [sqlite3_exec()] call are not
2304** reflected in subsequent calls to [sqlite3_errcode()] or
2305** [sqlite3_errmsg()].
2306*/
2307SQLITE_API int sqlite3_get_table(
2308  sqlite3 *db,          /* An open database */
2309  const char *zSql,     /* SQL to be evaluated */
2310  char ***pazResult,    /* Results of the query */
2311  int *pnRow,           /* Number of result rows written here */
2312  int *pnColumn,        /* Number of result columns written here */
2313  char **pzErrmsg       /* Error msg written here */
2314);
2315SQLITE_API void sqlite3_free_table(char **result);
2316
2317/*
2318** CAPI3REF: Formatted String Printing Functions
2319**
2320** These routines are work-alikes of the "printf()" family of functions
2321** from the standard C library.
2322**
2323** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
2324** results into memory obtained from [sqlite3_malloc()].
2325** The strings returned by these two routines should be
2326** released by [sqlite3_free()].  ^Both routines return a
2327** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
2328** memory to hold the resulting string.
2329**
2330** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
2331** the standard C library.  The result is written into the
2332** buffer supplied as the second parameter whose size is given by
2333** the first parameter. Note that the order of the
2334** first two parameters is reversed from snprintf().)^  This is an
2335** historical accident that cannot be fixed without breaking
2336** backwards compatibility.  ^(Note also that sqlite3_snprintf()
2337** returns a pointer to its buffer instead of the number of
2338** characters actually written into the buffer.)^  We admit that
2339** the number of characters written would be a more useful return
2340** value but we cannot change the implementation of sqlite3_snprintf()
2341** now without breaking compatibility.
2342**
2343** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
2344** guarantees that the buffer is always zero-terminated.  ^The first
2345** parameter "n" is the total size of the buffer, including space for
2346** the zero terminator.  So the longest string that can be completely
2347** written will be n-1 characters.
2348**
2349** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
2350**
2351** These routines all implement some additional formatting
2352** options that are useful for constructing SQL statements.
2353** All of the usual printf() formatting options apply.  In addition, there
2354** is are "%q", "%Q", and "%z" options.
2355**
2356** ^(The %q option works like %s in that it substitutes a nul-terminated
2357** string from the argument list.  But %q also doubles every '\'' character.
2358** %q is designed for use inside a string literal.)^  By doubling each '\''
2359** character it escapes that character and allows it to be inserted into
2360** the string.
2361**
2362** For example, assume the string variable zText contains text as follows:
2363**
2364** <blockquote><pre>
2365**  char *zText = "It's a happy day!";
2366** </pre></blockquote>
2367**
2368** One can use this text in an SQL statement as follows:
2369**
2370** <blockquote><pre>
2371**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
2372**  sqlite3_exec(db, zSQL, 0, 0, 0);
2373**  sqlite3_free(zSQL);
2374** </pre></blockquote>
2375**
2376** Because the %q format string is used, the '\'' character in zText
2377** is escaped and the SQL generated is as follows:
2378**
2379** <blockquote><pre>
2380**  INSERT INTO table1 VALUES('It''s a happy day!')
2381** </pre></blockquote>
2382**
2383** This is correct.  Had we used %s instead of %q, the generated SQL
2384** would have looked like this:
2385**
2386** <blockquote><pre>
2387**  INSERT INTO table1 VALUES('It's a happy day!');
2388** </pre></blockquote>
2389**
2390** This second example is an SQL syntax error.  As a general rule you should
2391** always use %q instead of %s when inserting text into a string literal.
2392**
2393** ^(The %Q option works like %q except it also adds single quotes around
2394** the outside of the total string.  Additionally, if the parameter in the
2395** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
2396** single quotes).)^  So, for example, one could say:
2397**
2398** <blockquote><pre>
2399**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
2400**  sqlite3_exec(db, zSQL, 0, 0, 0);
2401**  sqlite3_free(zSQL);
2402** </pre></blockquote>
2403**
2404** The code above will render a correct SQL statement in the zSQL
2405** variable even if the zText variable is a NULL pointer.
2406**
2407** ^(The "%z" formatting option works like "%s" but with the
2408** addition that after the string has been read and copied into
2409** the result, [sqlite3_free()] is called on the input string.)^
2410*/
2411SQLITE_API char *sqlite3_mprintf(const char*,...);
2412SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
2413SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
2414SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
2415
2416/*
2417** CAPI3REF: Memory Allocation Subsystem
2418**
2419** The SQLite core uses these three routines for all of its own
2420** internal memory allocation needs. "Core" in the previous sentence
2421** does not include operating-system specific VFS implementation.  The
2422** Windows VFS uses native malloc() and free() for some operations.
2423**
2424** ^The sqlite3_malloc() routine returns a pointer to a block
2425** of memory at least N bytes in length, where N is the parameter.
2426** ^If sqlite3_malloc() is unable to obtain sufficient free
2427** memory, it returns a NULL pointer.  ^If the parameter N to
2428** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
2429** a NULL pointer.
2430**
2431** ^The sqlite3_malloc64(N) routine works just like
2432** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead
2433** of a signed 32-bit integer.
2434**
2435** ^Calling sqlite3_free() with a pointer previously returned
2436** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
2437** that it might be reused.  ^The sqlite3_free() routine is
2438** a no-op if is called with a NULL pointer.  Passing a NULL pointer
2439** to sqlite3_free() is harmless.  After being freed, memory
2440** should neither be read nor written.  Even reading previously freed
2441** memory might result in a segmentation fault or other severe error.
2442** Memory corruption, a segmentation fault, or other severe error
2443** might result if sqlite3_free() is called with a non-NULL pointer that
2444** was not obtained from sqlite3_malloc() or sqlite3_realloc().
2445**
2446** ^The sqlite3_realloc(X,N) interface attempts to resize a
2447** prior memory allocation X to be at least N bytes.
2448** ^If the X parameter to sqlite3_realloc(X,N)
2449** is a NULL pointer then its behavior is identical to calling
2450** sqlite3_malloc(N).
2451** ^If the N parameter to sqlite3_realloc(X,N) is zero or
2452** negative then the behavior is exactly the same as calling
2453** sqlite3_free(X).
2454** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation
2455** of at least N bytes in size or NULL if insufficient memory is available.
2456** ^If M is the size of the prior allocation, then min(N,M) bytes
2457** of the prior allocation are copied into the beginning of buffer returned
2458** by sqlite3_realloc(X,N) and the prior allocation is freed.
2459** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the
2460** prior allocation is not freed.
2461**
2462** ^The sqlite3_realloc64(X,N) interfaces works the same as
2463** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead
2464** of a 32-bit signed integer.
2465**
2466** ^If X is a memory allocation previously obtained from sqlite3_malloc(),
2467** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then
2468** sqlite3_msize(X) returns the size of that memory allocation in bytes.
2469** ^The value returned by sqlite3_msize(X) might be larger than the number
2470** of bytes requested when X was allocated.  ^If X is a NULL pointer then
2471** sqlite3_msize(X) returns zero.  If X points to something that is not
2472** the beginning of memory allocation, or if it points to a formerly
2473** valid memory allocation that has now been freed, then the behavior
2474** of sqlite3_msize(X) is undefined and possibly harmful.
2475**
2476** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(),
2477** sqlite3_malloc64(), and sqlite3_realloc64()
2478** is always aligned to at least an 8 byte boundary, or to a
2479** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
2480** option is used.
2481**
2482** In SQLite version 3.5.0 and 3.5.1, it was possible to define
2483** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
2484** implementation of these routines to be omitted.  That capability
2485** is no longer provided.  Only built-in memory allocators can be used.
2486**
2487** Prior to SQLite version 3.7.10, the Windows OS interface layer called
2488** the system malloc() and free() directly when converting
2489** filenames between the UTF-8 encoding used by SQLite
2490** and whatever filename encoding is used by the particular Windows
2491** installation.  Memory allocation errors were detected, but
2492** they were reported back as [SQLITE_CANTOPEN] or
2493** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
2494**
2495** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
2496** must be either NULL or else pointers obtained from a prior
2497** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
2498** not yet been released.
2499**
2500** The application must not read or write any part of
2501** a block of memory after it has been released using
2502** [sqlite3_free()] or [sqlite3_realloc()].
2503*/
2504SQLITE_API void *sqlite3_malloc(int);
2505SQLITE_API void *sqlite3_malloc64(sqlite3_uint64);
2506SQLITE_API void *sqlite3_realloc(void*, int);
2507SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64);
2508SQLITE_API void sqlite3_free(void*);
2509SQLITE_API sqlite3_uint64 sqlite3_msize(void*);
2510
2511/*
2512** CAPI3REF: Memory Allocator Statistics
2513**
2514** SQLite provides these two interfaces for reporting on the status
2515** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
2516** routines, which form the built-in memory allocation subsystem.
2517**
2518** ^The [sqlite3_memory_used()] routine returns the number of bytes
2519** of memory currently outstanding (malloced but not freed).
2520** ^The [sqlite3_memory_highwater()] routine returns the maximum
2521** value of [sqlite3_memory_used()] since the high-water mark
2522** was last reset.  ^The values returned by [sqlite3_memory_used()] and
2523** [sqlite3_memory_highwater()] include any overhead
2524** added by SQLite in its implementation of [sqlite3_malloc()],
2525** but not overhead added by the any underlying system library
2526** routines that [sqlite3_malloc()] may call.
2527**
2528** ^The memory high-water mark is reset to the current value of
2529** [sqlite3_memory_used()] if and only if the parameter to
2530** [sqlite3_memory_highwater()] is true.  ^The value returned
2531** by [sqlite3_memory_highwater(1)] is the high-water mark
2532** prior to the reset.
2533*/
2534SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
2535SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
2536
2537/*
2538** CAPI3REF: Pseudo-Random Number Generator
2539**
2540** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
2541** select random [ROWID | ROWIDs] when inserting new records into a table that
2542** already uses the largest possible [ROWID].  The PRNG is also used for
2543** the build-in random() and randomblob() SQL functions.  This interface allows
2544** applications to access the same PRNG for other purposes.
2545**
2546** ^A call to this routine stores N bytes of randomness into buffer P.
2547** ^If N is less than one, then P can be a NULL pointer.
2548**
2549** ^If this routine has not been previously called or if the previous
2550** call had N less than one, then the PRNG is seeded using randomness
2551** obtained from the xRandomness method of the default [sqlite3_vfs] object.
2552** ^If the previous call to this routine had an N of 1 or more then
2553** the pseudo-randomness is generated
2554** internally and without recourse to the [sqlite3_vfs] xRandomness
2555** method.
2556*/
2557SQLITE_API void sqlite3_randomness(int N, void *P);
2558
2559/*
2560** CAPI3REF: Compile-Time Authorization Callbacks
2561**
2562** ^This routine registers an authorizer callback with a particular
2563** [database connection], supplied in the first argument.
2564** ^The authorizer callback is invoked as SQL statements are being compiled
2565** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
2566** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  ^At various
2567** points during the compilation process, as logic is being created
2568** to perform various actions, the authorizer callback is invoked to
2569** see if those actions are allowed.  ^The authorizer callback should
2570** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
2571** specific action but allow the SQL statement to continue to be
2572** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
2573** rejected with an error.  ^If the authorizer callback returns
2574** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
2575** then the [sqlite3_prepare_v2()] or equivalent call that triggered
2576** the authorizer will fail with an error message.
2577**
2578** When the callback returns [SQLITE_OK], that means the operation
2579** requested is ok.  ^When the callback returns [SQLITE_DENY], the
2580** [sqlite3_prepare_v2()] or equivalent call that triggered the
2581** authorizer will fail with an error message explaining that
2582** access is denied.
2583**
2584** ^The first parameter to the authorizer callback is a copy of the third
2585** parameter to the sqlite3_set_authorizer() interface. ^The second parameter
2586** to the callback is an integer [SQLITE_COPY | action code] that specifies
2587** the particular action to be authorized. ^The third through sixth parameters
2588** to the callback are zero-terminated strings that contain additional
2589** details about the action to be authorized.
2590**
2591** ^If the action code is [SQLITE_READ]
2592** and the callback returns [SQLITE_IGNORE] then the
2593** [prepared statement] statement is constructed to substitute
2594** a NULL value in place of the table column that would have
2595** been read if [SQLITE_OK] had been returned.  The [SQLITE_IGNORE]
2596** return can be used to deny an untrusted user access to individual
2597** columns of a table.
2598** ^If the action code is [SQLITE_DELETE] and the callback returns
2599** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
2600** [truncate optimization] is disabled and all rows are deleted individually.
2601**
2602** An authorizer is used when [sqlite3_prepare | preparing]
2603** SQL statements from an untrusted source, to ensure that the SQL statements
2604** do not try to access data they are not allowed to see, or that they do not
2605** try to execute malicious statements that damage the database.  For
2606** example, an application may allow a user to enter arbitrary
2607** SQL queries for evaluation by a database.  But the application does
2608** not want the user to be able to make arbitrary changes to the
2609** database.  An authorizer could then be put in place while the
2610** user-entered SQL is being [sqlite3_prepare | prepared] that
2611** disallows everything except [SELECT] statements.
2612**
2613** Applications that need to process SQL from untrusted sources
2614** might also consider lowering resource limits using [sqlite3_limit()]
2615** and limiting database size using the [max_page_count] [PRAGMA]
2616** in addition to using an authorizer.
2617**
2618** ^(Only a single authorizer can be in place on a database connection
2619** at a time.  Each call to sqlite3_set_authorizer overrides the
2620** previous call.)^  ^Disable the authorizer by installing a NULL callback.
2621** The authorizer is disabled by default.
2622**
2623** The authorizer callback must not do anything that will modify
2624** the database connection that invoked the authorizer callback.
2625** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
2626** database connections for the meaning of "modify" in this paragraph.
2627**
2628** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
2629** statement might be re-prepared during [sqlite3_step()] due to a
2630** schema change.  Hence, the application should ensure that the
2631** correct authorizer callback remains in place during the [sqlite3_step()].
2632**
2633** ^Note that the authorizer callback is invoked only during
2634** [sqlite3_prepare()] or its variants.  Authorization is not
2635** performed during statement evaluation in [sqlite3_step()], unless
2636** as stated in the previous paragraph, sqlite3_step() invokes
2637** sqlite3_prepare_v2() to reprepare a statement after a schema change.
2638*/
2639SQLITE_API int sqlite3_set_authorizer(
2640  sqlite3*,
2641  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
2642  void *pUserData
2643);
2644
2645/*
2646** CAPI3REF: Authorizer Return Codes
2647**
2648** The [sqlite3_set_authorizer | authorizer callback function] must
2649** return either [SQLITE_OK] or one of these two constants in order
2650** to signal SQLite whether or not the action is permitted.  See the
2651** [sqlite3_set_authorizer | authorizer documentation] for additional
2652** information.
2653**
2654** Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
2655** returned from the [sqlite3_vtab_on_conflict()] interface.
2656*/
2657#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
2658#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
2659
2660/*
2661** CAPI3REF: Authorizer Action Codes
2662**
2663** The [sqlite3_set_authorizer()] interface registers a callback function
2664** that is invoked to authorize certain SQL statement actions.  The
2665** second parameter to the callback is an integer code that specifies
2666** what action is being authorized.  These are the integer action codes that
2667** the authorizer callback may be passed.
2668**
2669** These action code values signify what kind of operation is to be
2670** authorized.  The 3rd and 4th parameters to the authorization
2671** callback function will be parameters or NULL depending on which of these
2672** codes is used as the second parameter.  ^(The 5th parameter to the
2673** authorizer callback is the name of the database ("main", "temp",
2674** etc.) if applicable.)^  ^The 6th parameter to the authorizer callback
2675** is the name of the inner-most trigger or view that is responsible for
2676** the access attempt or NULL if this access attempt is directly from
2677** top-level SQL code.
2678*/
2679/******************************************* 3rd ************ 4th ***********/
2680#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
2681#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
2682#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
2683#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
2684#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
2685#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
2686#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
2687#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
2688#define SQLITE_DELETE                9   /* Table Name      NULL            */
2689#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
2690#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
2691#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
2692#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
2693#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
2694#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
2695#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
2696#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
2697#define SQLITE_INSERT               18   /* Table Name      NULL            */
2698#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
2699#define SQLITE_READ                 20   /* Table Name      Column Name     */
2700#define SQLITE_SELECT               21   /* NULL            NULL            */
2701#define SQLITE_TRANSACTION          22   /* Operation       NULL            */
2702#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
2703#define SQLITE_ATTACH               24   /* Filename        NULL            */
2704#define SQLITE_DETACH               25   /* Database Name   NULL            */
2705#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
2706#define SQLITE_REINDEX              27   /* Index Name      NULL            */
2707#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
2708#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
2709#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
2710#define SQLITE_FUNCTION             31   /* NULL            Function Name   */
2711#define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
2712#define SQLITE_COPY                  0   /* No longer used */
2713#define SQLITE_RECURSIVE            33   /* NULL            NULL            */
2714
2715/*
2716** CAPI3REF: Tracing And Profiling Functions
2717**
2718** These routines register callback functions that can be used for
2719** tracing and profiling the execution of SQL statements.
2720**
2721** ^The callback function registered by sqlite3_trace() is invoked at
2722** various times when an SQL statement is being run by [sqlite3_step()].
2723** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
2724** SQL statement text as the statement first begins executing.
2725** ^(Additional sqlite3_trace() callbacks might occur
2726** as each triggered subprogram is entered.  The callbacks for triggers
2727** contain a UTF-8 SQL comment that identifies the trigger.)^
2728**
2729** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
2730** the length of [bound parameter] expansion in the output of sqlite3_trace().
2731**
2732** ^The callback function registered by sqlite3_profile() is invoked
2733** as each SQL statement finishes.  ^The profile callback contains
2734** the original statement text and an estimate of wall-clock time
2735** of how long that statement took to run.  ^The profile callback
2736** time is in units of nanoseconds, however the current implementation
2737** is only capable of millisecond resolution so the six least significant
2738** digits in the time are meaningless.  Future versions of SQLite
2739** might provide greater resolution on the profiler callback.  The
2740** sqlite3_profile() function is considered experimental and is
2741** subject to change in future versions of SQLite.
2742*/
2743SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
2744SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
2745   void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
2746
2747/*
2748** CAPI3REF: Query Progress Callbacks
2749**
2750** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
2751** function X to be invoked periodically during long running calls to
2752** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for
2753** database connection D.  An example use for this
2754** interface is to keep a GUI updated during a large query.
2755**
2756** ^The parameter P is passed through as the only parameter to the
2757** callback function X.  ^The parameter N is the approximate number of
2758** [virtual machine instructions] that are evaluated between successive
2759** invocations of the callback X.  ^If N is less than one then the progress
2760** handler is disabled.
2761**
2762** ^Only a single progress handler may be defined at one time per
2763** [database connection]; setting a new progress handler cancels the
2764** old one.  ^Setting parameter X to NULL disables the progress handler.
2765** ^The progress handler is also disabled by setting N to a value less
2766** than 1.
2767**
2768** ^If the progress callback returns non-zero, the operation is
2769** interrupted.  This feature can be used to implement a
2770** "Cancel" button on a GUI progress dialog box.
2771**
2772** The progress handler callback must not do anything that will modify
2773** the database connection that invoked the progress handler.
2774** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
2775** database connections for the meaning of "modify" in this paragraph.
2776**
2777*/
2778SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
2779
2780/*
2781** CAPI3REF: Opening A New Database Connection
2782**
2783** ^These routines open an SQLite database file as specified by the
2784** filename argument. ^The filename argument is interpreted as UTF-8 for
2785** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
2786** order for sqlite3_open16(). ^(A [database connection] handle is usually
2787** returned in *ppDb, even if an error occurs.  The only exception is that
2788** if SQLite is unable to allocate memory to hold the [sqlite3] object,
2789** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
2790** object.)^ ^(If the database is opened (and/or created) successfully, then
2791** [SQLITE_OK] is returned.  Otherwise an [error code] is returned.)^ ^The
2792** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
2793** an English language description of the error following a failure of any
2794** of the sqlite3_open() routines.
2795**
2796** ^The default encoding will be UTF-8 for databases created using
2797** sqlite3_open() or sqlite3_open_v2().  ^The default encoding for databases
2798** created using sqlite3_open16() will be UTF-16 in the native byte order.
2799**
2800** Whether or not an error occurs when it is opened, resources
2801** associated with the [database connection] handle should be released by
2802** passing it to [sqlite3_close()] when it is no longer required.
2803**
2804** The sqlite3_open_v2() interface works like sqlite3_open()
2805** except that it accepts two additional parameters for additional control
2806** over the new database connection.  ^(The flags parameter to
2807** sqlite3_open_v2() can take one of
2808** the following three values, optionally combined with the
2809** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
2810** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^
2811**
2812** <dl>
2813** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
2814** <dd>The database is opened in read-only mode.  If the database does not
2815** already exist, an error is returned.</dd>)^
2816**
2817** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
2818** <dd>The database is opened for reading and writing if possible, or reading
2819** only if the file is write protected by the operating system.  In either
2820** case the database must already exist, otherwise an error is returned.</dd>)^
2821**
2822** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
2823** <dd>The database is opened for reading and writing, and is created if
2824** it does not already exist. This is the behavior that is always used for
2825** sqlite3_open() and sqlite3_open16().</dd>)^
2826** </dl>
2827**
2828** If the 3rd parameter to sqlite3_open_v2() is not one of the
2829** combinations shown above optionally combined with other
2830** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
2831** then the behavior is undefined.
2832**
2833** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
2834** opens in the multi-thread [threading mode] as long as the single-thread
2835** mode has not been set at compile-time or start-time.  ^If the
2836** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
2837** in the serialized [threading mode] unless single-thread was
2838** previously selected at compile-time or start-time.
2839** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
2840** eligible to use [shared cache mode], regardless of whether or not shared
2841** cache is enabled using [sqlite3_enable_shared_cache()].  ^The
2842** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
2843** participate in [shared cache mode] even if it is enabled.
2844**
2845** ^The fourth parameter to sqlite3_open_v2() is the name of the
2846** [sqlite3_vfs] object that defines the operating system interface that
2847** the new database connection should use.  ^If the fourth parameter is
2848** a NULL pointer then the default [sqlite3_vfs] object is used.
2849**
2850** ^If the filename is ":memory:", then a private, temporary in-memory database
2851** is created for the connection.  ^This in-memory database will vanish when
2852** the database connection is closed.  Future versions of SQLite might
2853** make use of additional special filenames that begin with the ":" character.
2854** It is recommended that when a database filename actually does begin with
2855** a ":" character you should prefix the filename with a pathname such as
2856** "./" to avoid ambiguity.
2857**
2858** ^If the filename is an empty string, then a private, temporary
2859** on-disk database will be created.  ^This private database will be
2860** automatically deleted as soon as the database connection is closed.
2861**
2862** [[URI filenames in sqlite3_open()]] <h3>URI Filenames</h3>
2863**
2864** ^If [URI filename] interpretation is enabled, and the filename argument
2865** begins with "file:", then the filename is interpreted as a URI. ^URI
2866** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
2867** set in the fourth argument to sqlite3_open_v2(), or if it has
2868** been enabled globally using the [SQLITE_CONFIG_URI] option with the
2869** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
2870** As of SQLite version 3.7.7, URI filename interpretation is turned off
2871** by default, but future releases of SQLite might enable URI filename
2872** interpretation by default.  See "[URI filenames]" for additional
2873** information.
2874**
2875** URI filenames are parsed according to RFC 3986. ^If the URI contains an
2876** authority, then it must be either an empty string or the string
2877** "localhost". ^If the authority is not an empty string or "localhost", an
2878** error is returned to the caller. ^The fragment component of a URI, if
2879** present, is ignored.
2880**
2881** ^SQLite uses the path component of the URI as the name of the disk file
2882** which contains the database. ^If the path begins with a '/' character,
2883** then it is interpreted as an absolute path. ^If the path does not begin
2884** with a '/' (meaning that the authority section is omitted from the URI)
2885** then the path is interpreted as a relative path.
2886** ^(On windows, the first component of an absolute path
2887** is a drive specification (e.g. "C:").)^
2888**
2889** [[core URI query parameters]]
2890** The query component of a URI may contain parameters that are interpreted
2891** either by SQLite itself, or by a [VFS | custom VFS implementation].
2892** SQLite and its built-in [VFSes] interpret the
2893** following query parameters:
2894**
2895** <ul>
2896**   <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
2897**     a VFS object that provides the operating system interface that should
2898**     be used to access the database file on disk. ^If this option is set to
2899**     an empty string the default VFS object is used. ^Specifying an unknown
2900**     VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is
2901**     present, then the VFS specified by the option takes precedence over
2902**     the value passed as the fourth parameter to sqlite3_open_v2().
2903**
2904**   <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw",
2905**     "rwc", or "memory". Attempting to set it to any other value is
2906**     an error)^.
2907**     ^If "ro" is specified, then the database is opened for read-only
2908**     access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
2909**     third argument to sqlite3_open_v2(). ^If the mode option is set to
2910**     "rw", then the database is opened for read-write (but not create)
2911**     access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
2912**     been set. ^Value "rwc" is equivalent to setting both
2913**     SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE.  ^If the mode option is
2914**     set to "memory" then a pure [in-memory database] that never reads
2915**     or writes from disk is used. ^It is an error to specify a value for
2916**     the mode parameter that is less restrictive than that specified by
2917**     the flags passed in the third parameter to sqlite3_open_v2().
2918**
2919**   <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
2920**     "private". ^Setting it to "shared" is equivalent to setting the
2921**     SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to
2922**     sqlite3_open_v2(). ^Setting the cache parameter to "private" is
2923**     equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit.
2924**     ^If sqlite3_open_v2() is used and the "cache" parameter is present in
2925**     a URI filename, its value overrides any behavior requested by setting
2926**     SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
2927**
2928**  <li> <b>psow</b>: ^The psow parameter indicates whether or not the
2929**     [powersafe overwrite] property does or does not apply to the
2930**     storage media on which the database file resides.
2931**
2932**  <li> <b>nolock</b>: ^The nolock parameter is a boolean query parameter
2933**     which if set disables file locking in rollback journal modes.  This
2934**     is useful for accessing a database on a filesystem that does not
2935**     support locking.  Caution:  Database corruption might result if two
2936**     or more processes write to the same database and any one of those
2937**     processes uses nolock=1.
2938**
2939**  <li> <b>immutable</b>: ^The immutable parameter is a boolean query
2940**     parameter that indicates that the database file is stored on
2941**     read-only media.  ^When immutable is set, SQLite assumes that the
2942**     database file cannot be changed, even by a process with higher
2943**     privilege, and so the database is opened read-only and all locking
2944**     and change detection is disabled.  Caution: Setting the immutable
2945**     property on a database file that does in fact change can result
2946**     in incorrect query results and/or [SQLITE_CORRUPT] errors.
2947**     See also: [SQLITE_IOCAP_IMMUTABLE].
2948**
2949** </ul>
2950**
2951** ^Specifying an unknown parameter in the query component of a URI is not an
2952** error.  Future versions of SQLite might understand additional query
2953** parameters.  See "[query parameters with special meaning to SQLite]" for
2954** additional information.
2955**
2956** [[URI filename examples]] <h3>URI filename examples</h3>
2957**
2958** <table border="1" align=center cellpadding=5>
2959** <tr><th> URI filenames <th> Results
2960** <tr><td> file:data.db <td>
2961**          Open the file "data.db" in the current directory.
2962** <tr><td> file:/home/fred/data.db<br>
2963**          file:///home/fred/data.db <br>
2964**          file://localhost/home/fred/data.db <br> <td>
2965**          Open the database file "/home/fred/data.db".
2966** <tr><td> file://darkstar/home/fred/data.db <td>
2967**          An error. "darkstar" is not a recognized authority.
2968** <tr><td style="white-space:nowrap">
2969**          file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
2970**     <td> Windows only: Open the file "data.db" on fred's desktop on drive
2971**          C:. Note that the %20 escaping in this example is not strictly
2972**          necessary - space characters can be used literally
2973**          in URI filenames.
2974** <tr><td> file:data.db?mode=ro&cache=private <td>
2975**          Open file "data.db" in the current directory for read-only access.
2976**          Regardless of whether or not shared-cache mode is enabled by
2977**          default, use a private cache.
2978** <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
2979**          Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
2980**          that uses dot-files in place of posix advisory locking.
2981** <tr><td> file:data.db?mode=readonly <td>
2982**          An error. "readonly" is not a valid option for the "mode" parameter.
2983** </table>
2984**
2985** ^URI hexadecimal escape sequences (%HH) are supported within the path and
2986** query components of a URI. A hexadecimal escape sequence consists of a
2987** percent sign - "%" - followed by exactly two hexadecimal digits
2988** specifying an octet value. ^Before the path or query components of a
2989** URI filename are interpreted, they are encoded using UTF-8 and all
2990** hexadecimal escape sequences replaced by a single byte containing the
2991** corresponding octet. If this process generates an invalid UTF-8 encoding,
2992** the results are undefined.
2993**
2994** <b>Note to Windows users:</b>  The encoding used for the filename argument
2995** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
2996** codepage is currently defined.  Filenames containing international
2997** characters must be converted to UTF-8 prior to passing them into
2998** sqlite3_open() or sqlite3_open_v2().
2999**
3000** <b>Note to Windows Runtime users:</b>  The temporary directory must be set
3001** prior to calling sqlite3_open() or sqlite3_open_v2().  Otherwise, various
3002** features that require the use of temporary files may fail.
3003**
3004** See also: [sqlite3_temp_directory]
3005*/
3006SQLITE_API int sqlite3_open(
3007  const char *filename,   /* Database filename (UTF-8) */
3008  sqlite3 **ppDb          /* OUT: SQLite db handle */
3009);
3010SQLITE_API int sqlite3_open16(
3011  const void *filename,   /* Database filename (UTF-16) */
3012  sqlite3 **ppDb          /* OUT: SQLite db handle */
3013);
3014SQLITE_API int sqlite3_open_v2(
3015  const char *filename,   /* Database filename (UTF-8) */
3016  sqlite3 **ppDb,         /* OUT: SQLite db handle */
3017  int flags,              /* Flags */
3018  const char *zVfs        /* Name of VFS module to use */
3019);
3020
3021/*
3022** CAPI3REF: Obtain Values For URI Parameters
3023**
3024** These are utility routines, useful to VFS implementations, that check
3025** to see if a database file was a URI that contained a specific query
3026** parameter, and if so obtains the value of that query parameter.
3027**
3028** If F is the database filename pointer passed into the xOpen() method of
3029** a VFS implementation when the flags parameter to xOpen() has one or
3030** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and
3031** P is the name of the query parameter, then
3032** sqlite3_uri_parameter(F,P) returns the value of the P
3033** parameter if it exists or a NULL pointer if P does not appear as a
3034** query parameter on F.  If P is a query parameter of F
3035** has no explicit value, then sqlite3_uri_parameter(F,P) returns
3036** a pointer to an empty string.
3037**
3038** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean
3039** parameter and returns true (1) or false (0) according to the value
3040** of P.  The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the
3041** value of query parameter P is one of "yes", "true", or "on" in any
3042** case or if the value begins with a non-zero number.  The
3043** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of
3044** query parameter P is one of "no", "false", or "off" in any case or
3045** if the value begins with a numeric zero.  If P is not a query
3046** parameter on F or if the value of P is does not match any of the
3047** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0).
3048**
3049** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
3050** 64-bit signed integer and returns that integer, or D if P does not
3051** exist.  If the value of P is something other than an integer, then
3052** zero is returned.
3053**
3054** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
3055** sqlite3_uri_boolean(F,P,B) returns B.  If F is not a NULL pointer and
3056** is not a database file pathname pointer that SQLite passed into the xOpen
3057** VFS method, then the behavior of this routine is undefined and probably
3058** undesirable.
3059*/
3060SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
3061SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
3062SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
3063
3064
3065/*
3066** CAPI3REF: Error Codes And Messages
3067**
3068** ^The sqlite3_errcode() interface returns the numeric [result code] or
3069** [extended result code] for the most recent failed sqlite3_* API call
3070** associated with a [database connection]. If a prior API call failed
3071** but the most recent API call succeeded, the return value from
3072** sqlite3_errcode() is undefined.  ^The sqlite3_extended_errcode()
3073** interface is the same except that it always returns the
3074** [extended result code] even when extended result codes are
3075** disabled.
3076**
3077** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
3078** text that describes the error, as either UTF-8 or UTF-16 respectively.
3079** ^(Memory to hold the error message string is managed internally.
3080** The application does not need to worry about freeing the result.
3081** However, the error string might be overwritten or deallocated by
3082** subsequent calls to other SQLite interface functions.)^
3083**
3084** ^The sqlite3_errstr() interface returns the English-language text
3085** that describes the [result code], as UTF-8.
3086** ^(Memory to hold the error message string is managed internally
3087** and must not be freed by the application)^.
3088**
3089** When the serialized [threading mode] is in use, it might be the
3090** case that a second error occurs on a separate thread in between
3091** the time of the first error and the call to these interfaces.
3092** When that happens, the second error will be reported since these
3093** interfaces always report the most recent result.  To avoid
3094** this, each thread can obtain exclusive use of the [database connection] D
3095** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
3096** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
3097** all calls to the interfaces listed here are completed.
3098**
3099** If an interface fails with SQLITE_MISUSE, that means the interface
3100** was invoked incorrectly by the application.  In that case, the
3101** error code and message may or may not be set.
3102*/
3103SQLITE_API int sqlite3_errcode(sqlite3 *db);
3104SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
3105SQLITE_API const char *sqlite3_errmsg(sqlite3*);
3106SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
3107SQLITE_API const char *sqlite3_errstr(int);
3108
3109/*
3110** CAPI3REF: SQL Statement Object
3111** KEYWORDS: {prepared statement} {prepared statements}
3112**
3113** An instance of this object represents a single SQL statement.
3114** This object is variously known as a "prepared statement" or a
3115** "compiled SQL statement" or simply as a "statement".
3116**
3117** The life of a statement object goes something like this:
3118**
3119** <ol>
3120** <li> Create the object using [sqlite3_prepare_v2()] or a related
3121**      function.
3122** <li> Bind values to [host parameters] using the sqlite3_bind_*()
3123**      interfaces.
3124** <li> Run the SQL by calling [sqlite3_step()] one or more times.
3125** <li> Reset the statement using [sqlite3_reset()] then go back
3126**      to step 2.  Do this zero or more times.
3127** <li> Destroy the object using [sqlite3_finalize()].
3128** </ol>
3129**
3130** Refer to documentation on individual methods above for additional
3131** information.
3132*/
3133typedef struct sqlite3_stmt sqlite3_stmt;
3134
3135/*
3136** CAPI3REF: Run-time Limits
3137**
3138** ^(This interface allows the size of various constructs to be limited
3139** on a connection by connection basis.  The first parameter is the
3140** [database connection] whose limit is to be set or queried.  The
3141** second parameter is one of the [limit categories] that define a
3142** class of constructs to be size limited.  The third parameter is the
3143** new limit for that construct.)^
3144**
3145** ^If the new limit is a negative number, the limit is unchanged.
3146** ^(For each limit category SQLITE_LIMIT_<i>NAME</i> there is a
3147** [limits | hard upper bound]
3148** set at compile-time by a C preprocessor macro called
3149** [limits | SQLITE_MAX_<i>NAME</i>].
3150** (The "_LIMIT_" in the name is changed to "_MAX_".))^
3151** ^Attempts to increase a limit above its hard upper bound are
3152** silently truncated to the hard upper bound.
3153**
3154** ^Regardless of whether or not the limit was changed, the
3155** [sqlite3_limit()] interface returns the prior value of the limit.
3156** ^Hence, to find the current value of a limit without changing it,
3157** simply invoke this interface with the third parameter set to -1.
3158**
3159** Run-time limits are intended for use in applications that manage
3160** both their own internal database and also databases that are controlled
3161** by untrusted external sources.  An example application might be a
3162** web browser that has its own databases for storing history and
3163** separate databases controlled by JavaScript applications downloaded
3164** off the Internet.  The internal databases can be given the
3165** large, default limits.  Databases managed by external sources can
3166** be given much smaller limits designed to prevent a denial of service
3167** attack.  Developers might also want to use the [sqlite3_set_authorizer()]
3168** interface to further control untrusted SQL.  The size of the database
3169** created by an untrusted script can be contained using the
3170** [max_page_count] [PRAGMA].
3171**
3172** New run-time limit categories may be added in future releases.
3173*/
3174SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
3175
3176/*
3177** CAPI3REF: Run-Time Limit Categories
3178** KEYWORDS: {limit category} {*limit categories}
3179**
3180** These constants define various performance limits
3181** that can be lowered at run-time using [sqlite3_limit()].
3182** The synopsis of the meanings of the various limits is shown below.
3183** Additional information is available at [limits | Limits in SQLite].
3184**
3185** <dl>
3186** [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
3187** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
3188**
3189** [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
3190** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
3191**
3192** [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
3193** <dd>The maximum number of columns in a table definition or in the
3194** result set of a [SELECT] or the maximum number of columns in an index
3195** or in an ORDER BY or GROUP BY clause.</dd>)^
3196**
3197** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
3198** <dd>The maximum depth of the parse tree on any expression.</dd>)^
3199**
3200** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
3201** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
3202**
3203** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
3204** <dd>The maximum number of instructions in a virtual machine program
3205** used to implement an SQL statement.  This limit is not currently
3206** enforced, though that might be added in some future release of
3207** SQLite.</dd>)^
3208**
3209** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
3210** <dd>The maximum number of arguments on a function.</dd>)^
3211**
3212** [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
3213** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
3214**
3215** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
3216** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
3217** <dd>The maximum length of the pattern argument to the [LIKE] or
3218** [GLOB] operators.</dd>)^
3219**
3220** [[SQLITE_LIMIT_VARIABLE_NUMBER]]
3221** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
3222** <dd>The maximum index number of any [parameter] in an SQL statement.)^
3223**
3224** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
3225** <dd>The maximum depth of recursion for triggers.</dd>)^
3226**
3227** [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
3228** <dd>The maximum number of auxiliary worker threads that a single
3229** [prepared statement] may start.</dd>)^
3230** </dl>
3231*/
3232#define SQLITE_LIMIT_LENGTH                    0
3233#define SQLITE_LIMIT_SQL_LENGTH                1
3234#define SQLITE_LIMIT_COLUMN                    2
3235#define SQLITE_LIMIT_EXPR_DEPTH                3
3236#define SQLITE_LIMIT_COMPOUND_SELECT           4
3237#define SQLITE_LIMIT_VDBE_OP                   5
3238#define SQLITE_LIMIT_FUNCTION_ARG              6
3239#define SQLITE_LIMIT_ATTACHED                  7
3240#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
3241#define SQLITE_LIMIT_VARIABLE_NUMBER           9
3242#define SQLITE_LIMIT_TRIGGER_DEPTH            10
3243#define SQLITE_LIMIT_WORKER_THREADS           11
3244
3245/*
3246** CAPI3REF: Compiling An SQL Statement
3247** KEYWORDS: {SQL statement compiler}
3248**
3249** To execute an SQL query, it must first be compiled into a byte-code
3250** program using one of these routines.
3251**
3252** The first argument, "db", is a [database connection] obtained from a
3253** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
3254** [sqlite3_open16()].  The database connection must not have been closed.
3255**
3256** The second argument, "zSql", is the statement to be compiled, encoded
3257** as either UTF-8 or UTF-16.  The sqlite3_prepare() and sqlite3_prepare_v2()
3258** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
3259** use UTF-16.
3260**
3261** ^If the nByte argument is less than zero, then zSql is read up to the
3262** first zero terminator. ^If nByte is non-negative, then it is the maximum
3263** number of  bytes read from zSql.  ^When nByte is non-negative, the
3264** zSql string ends at either the first '\000' or '\u0000' character or
3265** the nByte-th byte, whichever comes first. If the caller knows
3266** that the supplied string is nul-terminated, then there is a small
3267** performance advantage to be gained by passing an nByte parameter that
3268** is equal to the number of bytes in the input string <i>including</i>
3269** the nul-terminator bytes as this saves SQLite from having to
3270** make a copy of the input string.
3271**
3272** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3273** past the end of the first SQL statement in zSql.  These routines only
3274** compile the first statement in zSql, so *pzTail is left pointing to
3275** what remains uncompiled.
3276**
3277** ^*ppStmt is left pointing to a compiled [prepared statement] that can be
3278** executed using [sqlite3_step()].  ^If there is an error, *ppStmt is set
3279** to NULL.  ^If the input text contains no SQL (if the input is an empty
3280** string or a comment) then *ppStmt is set to NULL.
3281** The calling procedure is responsible for deleting the compiled
3282** SQL statement using [sqlite3_finalize()] after it has finished with it.
3283** ppStmt may not be NULL.
3284**
3285** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
3286** otherwise an [error code] is returned.
3287**
3288** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
3289** recommended for all new programs. The two older interfaces are retained
3290** for backwards compatibility, but their use is discouraged.
3291** ^In the "v2" interfaces, the prepared statement
3292** that is returned (the [sqlite3_stmt] object) contains a copy of the
3293** original SQL text. This causes the [sqlite3_step()] interface to
3294** behave differently in three ways:
3295**
3296** <ol>
3297** <li>
3298** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
3299** always used to do, [sqlite3_step()] will automatically recompile the SQL
3300** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY]
3301** retries will occur before sqlite3_step() gives up and returns an error.
3302** </li>
3303**
3304** <li>
3305** ^When an error occurs, [sqlite3_step()] will return one of the detailed
3306** [error codes] or [extended error codes].  ^The legacy behavior was that
3307** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
3308** and the application would have to make a second call to [sqlite3_reset()]
3309** in order to find the underlying cause of the problem. With the "v2" prepare
3310** interfaces, the underlying reason for the error is returned immediately.
3311** </li>
3312**
3313** <li>
3314** ^If the specific value bound to [parameter | host parameter] in the
3315** WHERE clause might influence the choice of query plan for a statement,
3316** then the statement will be automatically recompiled, as if there had been
3317** a schema change, on the first  [sqlite3_step()] call following any change
3318** to the [sqlite3_bind_text | bindings] of that [parameter].
3319** ^The specific value of WHERE-clause [parameter] might influence the
3320** choice of query plan if the parameter is the left-hand side of a [LIKE]
3321** or [GLOB] operator or if the parameter is compared to an indexed column
3322** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
3323** </li>
3324** </ol>
3325*/
3326SQLITE_API int sqlite3_prepare(
3327  sqlite3 *db,            /* Database handle */
3328  const char *zSql,       /* SQL statement, UTF-8 encoded */
3329  int nByte,              /* Maximum length of zSql in bytes. */
3330  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
3331  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
3332);
3333SQLITE_API int sqlite3_prepare_v2(
3334  sqlite3 *db,            /* Database handle */
3335  const char *zSql,       /* SQL statement, UTF-8 encoded */
3336  int nByte,              /* Maximum length of zSql in bytes. */
3337  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
3338  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
3339);
3340SQLITE_API int sqlite3_prepare16(
3341  sqlite3 *db,            /* Database handle */
3342  const void *zSql,       /* SQL statement, UTF-16 encoded */
3343  int nByte,              /* Maximum length of zSql in bytes. */
3344  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
3345  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
3346);
3347SQLITE_API int sqlite3_prepare16_v2(
3348  sqlite3 *db,            /* Database handle */
3349  const void *zSql,       /* SQL statement, UTF-16 encoded */
3350  int nByte,              /* Maximum length of zSql in bytes. */
3351  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
3352  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
3353);
3354
3355/*
3356** CAPI3REF: Retrieving Statement SQL
3357**
3358** ^This interface can be used to retrieve a saved copy of the original
3359** SQL text used to create a [prepared statement] if that statement was
3360** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
3361*/
3362SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
3363
3364/*
3365** CAPI3REF: Determine If An SQL Statement Writes The Database
3366**
3367** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
3368** and only if the [prepared statement] X makes no direct changes to
3369** the content of the database file.
3370**
3371** Note that [application-defined SQL functions] or
3372** [virtual tables] might change the database indirectly as a side effect.
3373** ^(For example, if an application defines a function "eval()" that
3374** calls [sqlite3_exec()], then the following SQL statement would
3375** change the database file through side-effects:
3376**
3377** <blockquote><pre>
3378**    SELECT eval('DELETE FROM t1') FROM t2;
3379** </pre></blockquote>
3380**
3381** But because the [SELECT] statement does not change the database file
3382** directly, sqlite3_stmt_readonly() would still return true.)^
3383**
3384** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
3385** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true,
3386** since the statements themselves do not actually modify the database but
3387** rather they control the timing of when other statements modify the
3388** database.  ^The [ATTACH] and [DETACH] statements also cause
3389** sqlite3_stmt_readonly() to return true since, while those statements
3390** change the configuration of a database connection, they do not make
3391** changes to the content of the database files on disk.
3392*/
3393SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
3394
3395/*
3396** CAPI3REF: Determine If A Prepared Statement Has Been Reset
3397**
3398** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
3399** [prepared statement] S has been stepped at least once using
3400** [sqlite3_step(S)] but has not run to completion and/or has not
3401** been reset using [sqlite3_reset(S)].  ^The sqlite3_stmt_busy(S)
3402** interface returns false if S is a NULL pointer.  If S is not a
3403** NULL pointer and is not a pointer to a valid [prepared statement]
3404** object, then the behavior is undefined and probably undesirable.
3405**
3406** This interface can be used in combination [sqlite3_next_stmt()]
3407** to locate all prepared statements associated with a database
3408** connection that are in need of being reset.  This can be used,
3409** for example, in diagnostic routines to search for prepared
3410** statements that are holding a transaction open.
3411*/
3412SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
3413
3414/*
3415** CAPI3REF: Dynamically Typed Value Object
3416** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
3417**
3418** SQLite uses the sqlite3_value object to represent all values
3419** that can be stored in a database table. SQLite uses dynamic typing
3420** for the values it stores.  ^Values stored in sqlite3_value objects
3421** can be integers, floating point values, strings, BLOBs, or NULL.
3422**
3423** An sqlite3_value object may be either "protected" or "unprotected".
3424** Some interfaces require a protected sqlite3_value.  Other interfaces
3425** will accept either a protected or an unprotected sqlite3_value.
3426** Every interface that accepts sqlite3_value arguments specifies
3427** whether or not it requires a protected sqlite3_value.
3428**
3429** The terms "protected" and "unprotected" refer to whether or not
3430** a mutex is held.  An internal mutex is held for a protected
3431** sqlite3_value object but no mutex is held for an unprotected
3432** sqlite3_value object.  If SQLite is compiled to be single-threaded
3433** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
3434** or if SQLite is run in one of reduced mutex modes
3435** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
3436** then there is no distinction between protected and unprotected
3437** sqlite3_value objects and they can be used interchangeably.  However,
3438** for maximum code portability it is recommended that applications
3439** still make the distinction between protected and unprotected
3440** sqlite3_value objects even when not strictly required.
3441**
3442** ^The sqlite3_value objects that are passed as parameters into the
3443** implementation of [application-defined SQL functions] are protected.
3444** ^The sqlite3_value object returned by
3445** [sqlite3_column_value()] is unprotected.
3446** Unprotected sqlite3_value objects may only be used with
3447** [sqlite3_result_value()] and [sqlite3_bind_value()].
3448** The [sqlite3_value_blob | sqlite3_value_type()] family of
3449** interfaces require protected sqlite3_value objects.
3450*/
3451typedef struct Mem sqlite3_value;
3452
3453/*
3454** CAPI3REF: SQL Function Context Object
3455**
3456** The context in which an SQL function executes is stored in an
3457** sqlite3_context object.  ^A pointer to an sqlite3_context object
3458** is always first parameter to [application-defined SQL functions].
3459** The application-defined SQL function implementation will pass this
3460** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
3461** [sqlite3_aggregate_context()], [sqlite3_user_data()],
3462** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
3463** and/or [sqlite3_set_auxdata()].
3464*/
3465typedef struct sqlite3_context sqlite3_context;
3466
3467/*
3468** CAPI3REF: Binding Values To Prepared Statements
3469** KEYWORDS: {host parameter} {host parameters} {host parameter name}
3470** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
3471**
3472** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
3473** literals may be replaced by a [parameter] that matches one of following
3474** templates:
3475**
3476** <ul>
3477** <li>  ?
3478** <li>  ?NNN
3479** <li>  :VVV
3480** <li>  @VVV
3481** <li>  $VVV
3482** </ul>
3483**
3484** In the templates above, NNN represents an integer literal,
3485** and VVV represents an alphanumeric identifier.)^  ^The values of these
3486** parameters (also called "host parameter names" or "SQL parameters")
3487** can be set using the sqlite3_bind_*() routines defined here.
3488**
3489** ^The first argument to the sqlite3_bind_*() routines is always
3490** a pointer to the [sqlite3_stmt] object returned from
3491** [sqlite3_prepare_v2()] or its variants.
3492**
3493** ^The second argument is the index of the SQL parameter to be set.
3494** ^The leftmost SQL parameter has an index of 1.  ^When the same named
3495** SQL parameter is used more than once, second and subsequent
3496** occurrences have the same index as the first occurrence.
3497** ^The index for named parameters can be looked up using the
3498** [sqlite3_bind_parameter_index()] API if desired.  ^The index
3499** for "?NNN" parameters is the value of NNN.
3500** ^The NNN value must be between 1 and the [sqlite3_limit()]
3501** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
3502**
3503** ^The third argument is the value to bind to the parameter.
3504** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16()
3505** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter
3506** is ignored and the end result is the same as sqlite3_bind_null().
3507**
3508** ^(In those routines that have a fourth argument, its value is the
3509** number of bytes in the parameter.  To be clear: the value is the
3510** number of <u>bytes</u> in the value, not the number of characters.)^
3511** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16()
3512** is negative, then the length of the string is
3513** the number of bytes up to the first zero terminator.
3514** If the fourth parameter to sqlite3_bind_blob() is negative, then
3515** the behavior is undefined.
3516** If a non-negative fourth parameter is provided to sqlite3_bind_text()
3517** or sqlite3_bind_text16() or sqlite3_bind_text64() then
3518** that parameter must be the byte offset
3519** where the NUL terminator would occur assuming the string were NUL
3520** terminated.  If any NUL characters occur at byte offsets less than
3521** the value of the fourth parameter then the resulting string value will
3522** contain embedded NULs.  The result of expressions involving strings
3523** with embedded NULs is undefined.
3524**
3525** ^The fifth argument to the BLOB and string binding interfaces
3526** is a destructor used to dispose of the BLOB or
3527** string after SQLite has finished with it.  ^The destructor is called
3528** to dispose of the BLOB or string even if the call to bind API fails.
3529** ^If the fifth argument is
3530** the special value [SQLITE_STATIC], then SQLite assumes that the
3531** information is in static, unmanaged space and does not need to be freed.
3532** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
3533** SQLite makes its own private copy of the data immediately, before
3534** the sqlite3_bind_*() routine returns.
3535**
3536** ^The sixth argument to sqlite3_bind_text64() must be one of
3537** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
3538** to specify the encoding of the text in the third parameter.  If
3539** the sixth argument to sqlite3_bind_text64() is not one of the
3540** allowed values shown above, or if the text encoding is different
3541** from the encoding specified by the sixth parameter, then the behavior
3542** is undefined.
3543**
3544** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
3545** is filled with zeroes.  ^A zeroblob uses a fixed amount of memory
3546** (just an integer to hold its size) while it is being processed.
3547** Zeroblobs are intended to serve as placeholders for BLOBs whose
3548** content is later written using
3549** [sqlite3_blob_open | incremental BLOB I/O] routines.
3550** ^A negative value for the zeroblob results in a zero-length BLOB.
3551**
3552** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer
3553** for the [prepared statement] or with a prepared statement for which
3554** [sqlite3_step()] has been called more recently than [sqlite3_reset()],
3555** then the call will return [SQLITE_MISUSE].  If any sqlite3_bind_()
3556** routine is passed a [prepared statement] that has been finalized, the
3557** result is undefined and probably harmful.
3558**
3559** ^Bindings are not cleared by the [sqlite3_reset()] routine.
3560** ^Unbound parameters are interpreted as NULL.
3561**
3562** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
3563** [error code] if anything goes wrong.
3564** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB
3565** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or
3566** [SQLITE_MAX_LENGTH].
3567** ^[SQLITE_RANGE] is returned if the parameter
3568** index is out of range.  ^[SQLITE_NOMEM] is returned if malloc() fails.
3569**
3570** See also: [sqlite3_bind_parameter_count()],
3571** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
3572*/
3573SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
3574SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
3575                        void(*)(void*));
3576SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
3577SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
3578SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
3579SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
3580SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
3581SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
3582SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
3583                         void(*)(void*), unsigned char encoding);
3584SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
3585SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
3586
3587/*
3588** CAPI3REF: Number Of SQL Parameters
3589**
3590** ^This routine can be used to find the number of [SQL parameters]
3591** in a [prepared statement].  SQL parameters are tokens of the
3592** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
3593** placeholders for values that are [sqlite3_bind_blob | bound]
3594** to the parameters at a later time.
3595**
3596** ^(This routine actually returns the index of the largest (rightmost)
3597** parameter. For all forms except ?NNN, this will correspond to the
3598** number of unique parameters.  If parameters of the ?NNN form are used,
3599** there may be gaps in the list.)^
3600**
3601** See also: [sqlite3_bind_blob|sqlite3_bind()],
3602** [sqlite3_bind_parameter_name()], and
3603** [sqlite3_bind_parameter_index()].
3604*/
3605SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
3606
3607/*
3608** CAPI3REF: Name Of A Host Parameter
3609**
3610** ^The sqlite3_bind_parameter_name(P,N) interface returns
3611** the name of the N-th [SQL parameter] in the [prepared statement] P.
3612** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
3613** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
3614** respectively.
3615** In other words, the initial ":" or "$" or "@" or "?"
3616** is included as part of the name.)^
3617** ^Parameters of the form "?" without a following integer have no name
3618** and are referred to as "nameless" or "anonymous parameters".
3619**
3620** ^The first host parameter has an index of 1, not 0.
3621**
3622** ^If the value N is out of range or if the N-th parameter is
3623** nameless, then NULL is returned.  ^The returned string is
3624** always in UTF-8 encoding even if the named parameter was
3625** originally specified as UTF-16 in [sqlite3_prepare16()] or
3626** [sqlite3_prepare16_v2()].
3627**
3628** See also: [sqlite3_bind_blob|sqlite3_bind()],
3629** [sqlite3_bind_parameter_count()], and
3630** [sqlite3_bind_parameter_index()].
3631*/
3632SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
3633
3634/*
3635** CAPI3REF: Index Of A Parameter With A Given Name
3636**
3637** ^Return the index of an SQL parameter given its name.  ^The
3638** index value returned is suitable for use as the second
3639** parameter to [sqlite3_bind_blob|sqlite3_bind()].  ^A zero
3640** is returned if no matching parameter is found.  ^The parameter
3641** name must be given in UTF-8 even if the original statement
3642** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
3643**
3644** See also: [sqlite3_bind_blob|sqlite3_bind()],
3645** [sqlite3_bind_parameter_count()], and
3646** [sqlite3_bind_parameter_index()].
3647*/
3648SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
3649
3650/*
3651** CAPI3REF: Reset All Bindings On A Prepared Statement
3652**
3653** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
3654** the [sqlite3_bind_blob | bindings] on a [prepared statement].
3655** ^Use this routine to reset all host parameters to NULL.
3656*/
3657SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
3658
3659/*
3660** CAPI3REF: Number Of Columns In A Result Set
3661**
3662** ^Return the number of columns in the result set returned by the
3663** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
3664** statement that does not return data (for example an [UPDATE]).
3665**
3666** See also: [sqlite3_data_count()]
3667*/
3668SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
3669
3670/*
3671** CAPI3REF: Column Names In A Result Set
3672**
3673** ^These routines return the name assigned to a particular column
3674** in the result set of a [SELECT] statement.  ^The sqlite3_column_name()
3675** interface returns a pointer to a zero-terminated UTF-8 string
3676** and sqlite3_column_name16() returns a pointer to a zero-terminated
3677** UTF-16 string.  ^The first parameter is the [prepared statement]
3678** that implements the [SELECT] statement. ^The second parameter is the
3679** column number.  ^The leftmost column is number 0.
3680**
3681** ^The returned string pointer is valid until either the [prepared statement]
3682** is destroyed by [sqlite3_finalize()] or until the statement is automatically
3683** reprepared by the first call to [sqlite3_step()] for a particular run
3684** or until the next call to
3685** sqlite3_column_name() or sqlite3_column_name16() on the same column.
3686**
3687** ^If sqlite3_malloc() fails during the processing of either routine
3688** (for example during a conversion from UTF-8 to UTF-16) then a
3689** NULL pointer is returned.
3690**
3691** ^The name of a result column is the value of the "AS" clause for
3692** that column, if there is an AS clause.  If there is no AS clause
3693** then the name of the column is unspecified and may change from
3694** one release of SQLite to the next.
3695*/
3696SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
3697SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
3698
3699/*
3700** CAPI3REF: Source Of Data In A Query Result
3701**
3702** ^These routines provide a means to determine the database, table, and
3703** table column that is the origin of a particular result column in
3704** [SELECT] statement.
3705** ^The name of the database or table or column can be returned as
3706** either a UTF-8 or UTF-16 string.  ^The _database_ routines return
3707** the database name, the _table_ routines return the table name, and
3708** the origin_ routines return the column name.
3709** ^The returned string is valid until the [prepared statement] is destroyed
3710** using [sqlite3_finalize()] or until the statement is automatically
3711** reprepared by the first call to [sqlite3_step()] for a particular run
3712** or until the same information is requested
3713** again in a different encoding.
3714**
3715** ^The names returned are the original un-aliased names of the
3716** database, table, and column.
3717**
3718** ^The first argument to these interfaces is a [prepared statement].
3719** ^These functions return information about the Nth result column returned by
3720** the statement, where N is the second function argument.
3721** ^The left-most column is column 0 for these routines.
3722**
3723** ^If the Nth column returned by the statement is an expression or
3724** subquery and is not a column value, then all of these functions return
3725** NULL.  ^These routine might also return NULL if a memory allocation error
3726** occurs.  ^Otherwise, they return the name of the attached database, table,
3727** or column that query result column was extracted from.
3728**
3729** ^As with all other SQLite APIs, those whose names end with "16" return
3730** UTF-16 encoded strings and the other functions return UTF-8.
3731**
3732** ^These APIs are only available if the library was compiled with the
3733** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
3734**
3735** If two or more threads call one or more of these routines against the same
3736** prepared statement and column at the same time then the results are
3737** undefined.
3738**
3739** If two or more threads call one or more
3740** [sqlite3_column_database_name | column metadata interfaces]
3741** for the same [prepared statement] and result column
3742** at the same time then the results are undefined.
3743*/
3744SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
3745SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
3746SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
3747SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
3748SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
3749SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
3750
3751/*
3752** CAPI3REF: Declared Datatype Of A Query Result
3753**
3754** ^(The first parameter is a [prepared statement].
3755** If this statement is a [SELECT] statement and the Nth column of the
3756** returned result set of that [SELECT] is a table column (not an
3757** expression or subquery) then the declared type of the table
3758** column is returned.)^  ^If the Nth column of the result set is an
3759** expression or subquery, then a NULL pointer is returned.
3760** ^The returned string is always UTF-8 encoded.
3761**
3762** ^(For example, given the database schema:
3763**
3764** CREATE TABLE t1(c1 VARIANT);
3765**
3766** and the following statement to be compiled:
3767**
3768** SELECT c1 + 1, c1 FROM t1;
3769**
3770** this routine would return the string "VARIANT" for the second result
3771** column (i==1), and a NULL pointer for the first result column (i==0).)^
3772**
3773** ^SQLite uses dynamic run-time typing.  ^So just because a column
3774** is declared to contain a particular type does not mean that the
3775** data stored in that column is of the declared type.  SQLite is
3776** strongly typed, but the typing is dynamic not static.  ^Type
3777** is associated with individual values, not with the containers
3778** used to hold those values.
3779*/
3780SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
3781SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
3782
3783/*
3784** CAPI3REF: Evaluate An SQL Statement
3785**
3786** After a [prepared statement] has been prepared using either
3787** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
3788** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
3789** must be called one or more times to evaluate the statement.
3790**
3791** The details of the behavior of the sqlite3_step() interface depend
3792** on whether the statement was prepared using the newer "v2" interface
3793** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
3794** interface [sqlite3_prepare()] and [sqlite3_prepare16()].  The use of the
3795** new "v2" interface is recommended for new applications but the legacy
3796** interface will continue to be supported.
3797**
3798** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
3799** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
3800** ^With the "v2" interface, any of the other [result codes] or
3801** [extended result codes] might be returned as well.
3802**
3803** ^[SQLITE_BUSY] means that the database engine was unable to acquire the
3804** database locks it needs to do its job.  ^If the statement is a [COMMIT]
3805** or occurs outside of an explicit transaction, then you can retry the
3806** statement.  If the statement is not a [COMMIT] and occurs within an
3807** explicit transaction then you should rollback the transaction before
3808** continuing.
3809**
3810** ^[SQLITE_DONE] means that the statement has finished executing
3811** successfully.  sqlite3_step() should not be called again on this virtual
3812** machine without first calling [sqlite3_reset()] to reset the virtual
3813** machine back to its initial state.
3814**
3815** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
3816** is returned each time a new row of data is ready for processing by the
3817** caller. The values may be accessed using the [column access functions].
3818** sqlite3_step() is called again to retrieve the next row of data.
3819**
3820** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
3821** violation) has occurred.  sqlite3_step() should not be called again on
3822** the VM. More information may be found by calling [sqlite3_errmsg()].
3823** ^With the legacy interface, a more specific error code (for example,
3824** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
3825** can be obtained by calling [sqlite3_reset()] on the
3826** [prepared statement].  ^In the "v2" interface,
3827** the more specific error code is returned directly by sqlite3_step().
3828**
3829** [SQLITE_MISUSE] means that the this routine was called inappropriately.
3830** Perhaps it was called on a [prepared statement] that has
3831** already been [sqlite3_finalize | finalized] or on one that had
3832** previously returned [SQLITE_ERROR] or [SQLITE_DONE].  Or it could
3833** be the case that the same database connection is being used by two or
3834** more threads at the same moment in time.
3835**
3836** For all versions of SQLite up to and including 3.6.23.1, a call to
3837** [sqlite3_reset()] was required after sqlite3_step() returned anything
3838** other than [SQLITE_ROW] before any subsequent invocation of
3839** sqlite3_step().  Failure to reset the prepared statement using
3840** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
3841** sqlite3_step().  But after version 3.6.23.1, sqlite3_step() began
3842** calling [sqlite3_reset()] automatically in this circumstance rather
3843** than returning [SQLITE_MISUSE].  This is not considered a compatibility
3844** break because any application that ever receives an SQLITE_MISUSE error
3845** is broken by definition.  The [SQLITE_OMIT_AUTORESET] compile-time option
3846** can be used to restore the legacy behavior.
3847**
3848** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step()
3849** API always returns a generic error code, [SQLITE_ERROR], following any
3850** error other than [SQLITE_BUSY] and [SQLITE_MISUSE].  You must call
3851** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
3852** specific [error codes] that better describes the error.
3853** We admit that this is a goofy design.  The problem has been fixed
3854** with the "v2" interface.  If you prepare all of your SQL statements
3855** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
3856** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
3857** then the more specific [error codes] are returned directly
3858** by sqlite3_step().  The use of the "v2" interface is recommended.
3859*/
3860SQLITE_API int sqlite3_step(sqlite3_stmt*);
3861
3862/*
3863** CAPI3REF: Number of columns in a result set
3864**
3865** ^The sqlite3_data_count(P) interface returns the number of columns in the
3866** current row of the result set of [prepared statement] P.
3867** ^If prepared statement P does not have results ready to return
3868** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of
3869** interfaces) then sqlite3_data_count(P) returns 0.
3870** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer.
3871** ^The sqlite3_data_count(P) routine returns 0 if the previous call to
3872** [sqlite3_step](P) returned [SQLITE_DONE].  ^The sqlite3_data_count(P)
3873** will return non-zero if previous call to [sqlite3_step](P) returned
3874** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum]
3875** where it always returns zero since each step of that multi-step
3876** pragma returns 0 columns of data.
3877**
3878** See also: [sqlite3_column_count()]
3879*/
3880SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
3881
3882/*
3883** CAPI3REF: Fundamental Datatypes
3884** KEYWORDS: SQLITE_TEXT
3885**
3886** ^(Every value in SQLite has one of five fundamental datatypes:
3887**
3888** <ul>
3889** <li> 64-bit signed integer
3890** <li> 64-bit IEEE floating point number
3891** <li> string
3892** <li> BLOB
3893** <li> NULL
3894** </ul>)^
3895**
3896** These constants are codes for each of those types.
3897**
3898** Note that the SQLITE_TEXT constant was also used in SQLite version 2
3899** for a completely different meaning.  Software that links against both
3900** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
3901** SQLITE_TEXT.
3902*/
3903#define SQLITE_INTEGER  1
3904#define SQLITE_FLOAT    2
3905#define SQLITE_BLOB     4
3906#define SQLITE_NULL     5
3907#ifdef SQLITE_TEXT
3908# undef SQLITE_TEXT
3909#else
3910# define SQLITE_TEXT     3
3911#endif
3912#define SQLITE3_TEXT     3
3913
3914/*
3915** CAPI3REF: Result Values From A Query
3916** KEYWORDS: {column access functions}
3917**
3918** These routines form the "result set" interface.
3919**
3920** ^These routines return information about a single column of the current
3921** result row of a query.  ^In every case the first argument is a pointer
3922** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
3923** that was returned from [sqlite3_prepare_v2()] or one of its variants)
3924** and the second argument is the index of the column for which information
3925** should be returned. ^The leftmost column of the result set has the index 0.
3926** ^The number of columns in the result can be determined using
3927** [sqlite3_column_count()].
3928**
3929** If the SQL statement does not currently point to a valid row, or if the
3930** column index is out of range, the result is undefined.
3931** These routines may only be called when the most recent call to
3932** [sqlite3_step()] has returned [SQLITE_ROW] and neither
3933** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
3934** If any of these routines are called after [sqlite3_reset()] or
3935** [sqlite3_finalize()] or after [sqlite3_step()] has returned
3936** something other than [SQLITE_ROW], the results are undefined.
3937** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
3938** are called from a different thread while any of these routines
3939** are pending, then the results are undefined.
3940**
3941** ^The sqlite3_column_type() routine returns the
3942** [SQLITE_INTEGER | datatype code] for the initial data type
3943** of the result column.  ^The returned value is one of [SQLITE_INTEGER],
3944** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].  The value
3945** returned by sqlite3_column_type() is only meaningful if no type
3946** conversions have occurred as described below.  After a type conversion,
3947** the value returned by sqlite3_column_type() is undefined.  Future
3948** versions of SQLite may change the behavior of sqlite3_column_type()
3949** following a type conversion.
3950**
3951** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
3952** routine returns the number of bytes in that BLOB or string.
3953** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
3954** the string to UTF-8 and then returns the number of bytes.
3955** ^If the result is a numeric value then sqlite3_column_bytes() uses
3956** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
3957** the number of bytes in that string.
3958** ^If the result is NULL, then sqlite3_column_bytes() returns zero.
3959**
3960** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
3961** routine returns the number of bytes in that BLOB or string.
3962** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
3963** the string to UTF-16 and then returns the number of bytes.
3964** ^If the result is a numeric value then sqlite3_column_bytes16() uses
3965** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
3966** the number of bytes in that string.
3967** ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
3968**
3969** ^The values returned by [sqlite3_column_bytes()] and
3970** [sqlite3_column_bytes16()] do not include the zero terminators at the end
3971** of the string.  ^For clarity: the values returned by
3972** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of
3973** bytes in the string, not the number of characters.
3974**
3975** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
3976** even empty strings, are always zero-terminated.  ^The return
3977** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
3978**
3979** ^The object returned by [sqlite3_column_value()] is an
3980** [unprotected sqlite3_value] object.  An unprotected sqlite3_value object
3981** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()].
3982** If the [unprotected sqlite3_value] object returned by
3983** [sqlite3_column_value()] is used in any other way, including calls
3984** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
3985** or [sqlite3_value_bytes()], then the behavior is undefined.
3986**
3987** These routines attempt to convert the value where appropriate.  ^For
3988** example, if the internal representation is FLOAT and a text result
3989** is requested, [sqlite3_snprintf()] is used internally to perform the
3990** conversion automatically.  ^(The following table details the conversions
3991** that are applied:
3992**
3993** <blockquote>
3994** <table border="1">
3995** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
3996**
3997** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
3998** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
3999** <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
4000** <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
4001** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
4002** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
4003** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
4004** <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
4005** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
4006** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
4007** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
4008** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
4009** <tr><td>  TEXT    <td>   BLOB    <td> No change
4010** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
4011** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
4012** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
4013** </table>
4014** </blockquote>)^
4015**
4016** The table above makes reference to standard C library functions atoi()
4017** and atof().  SQLite does not really use these functions.  It has its
4018** own equivalent internal routines.  The atoi() and atof() names are
4019** used in the table for brevity and because they are familiar to most
4020** C programmers.
4021**
4022** Note that when type conversions occur, pointers returned by prior
4023** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
4024** sqlite3_column_text16() may be invalidated.
4025** Type conversions and pointer invalidations might occur
4026** in the following cases:
4027**
4028** <ul>
4029** <li> The initial content is a BLOB and sqlite3_column_text() or
4030**      sqlite3_column_text16() is called.  A zero-terminator might
4031**      need to be added to the string.</li>
4032** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
4033**      sqlite3_column_text16() is called.  The content must be converted
4034**      to UTF-16.</li>
4035** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
4036**      sqlite3_column_text() is called.  The content must be converted
4037**      to UTF-8.</li>
4038** </ul>
4039**
4040** ^Conversions between UTF-16be and UTF-16le are always done in place and do
4041** not invalidate a prior pointer, though of course the content of the buffer
4042** that the prior pointer references will have been modified.  Other kinds
4043** of conversion are done in place when it is possible, but sometimes they
4044** are not possible and in those cases prior pointers are invalidated.
4045**
4046** The safest and easiest to remember policy is to invoke these routines
4047** in one of the following ways:
4048**
4049** <ul>
4050**  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
4051**  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
4052**  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
4053** </ul>
4054**
4055** In other words, you should call sqlite3_column_text(),
4056** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
4057** into the desired format, then invoke sqlite3_column_bytes() or
4058** sqlite3_column_bytes16() to find the size of the result.  Do not mix calls
4059** to sqlite3_column_text() or sqlite3_column_blob() with calls to
4060** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
4061** with calls to sqlite3_column_bytes().
4062**
4063** ^The pointers returned are valid until a type conversion occurs as
4064** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
4065** [sqlite3_finalize()] is called.  ^The memory space used to hold strings
4066** and BLOBs is freed automatically.  Do <b>not</b> pass the pointers returned
4067** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
4068** [sqlite3_free()].
4069**
4070** ^(If a memory allocation error occurs during the evaluation of any
4071** of these routines, a default value is returned.  The default value
4072** is either the integer 0, the floating point number 0.0, or a NULL
4073** pointer.  Subsequent calls to [sqlite3_errcode()] will return
4074** [SQLITE_NOMEM].)^
4075*/
4076SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
4077SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
4078SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
4079SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
4080SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
4081SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
4082SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
4083SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
4084SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
4085SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
4086
4087/*
4088** CAPI3REF: Destroy A Prepared Statement Object
4089**
4090** ^The sqlite3_finalize() function is called to delete a [prepared statement].
4091** ^If the most recent evaluation of the statement encountered no errors
4092** or if the statement is never been evaluated, then sqlite3_finalize() returns
4093** SQLITE_OK.  ^If the most recent evaluation of statement S failed, then
4094** sqlite3_finalize(S) returns the appropriate [error code] or
4095** [extended error code].
4096**
4097** ^The sqlite3_finalize(S) routine can be called at any point during
4098** the life cycle of [prepared statement] S:
4099** before statement S is ever evaluated, after
4100** one or more calls to [sqlite3_reset()], or after any call
4101** to [sqlite3_step()] regardless of whether or not the statement has
4102** completed execution.
4103**
4104** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
4105**
4106** The application must finalize every [prepared statement] in order to avoid
4107** resource leaks.  It is a grievous error for the application to try to use
4108** a prepared statement after it has been finalized.  Any use of a prepared
4109** statement after it has been finalized can result in undefined and
4110** undesirable behavior such as segfaults and heap corruption.
4111*/
4112SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
4113
4114/*
4115** CAPI3REF: Reset A Prepared Statement Object
4116**
4117** The sqlite3_reset() function is called to reset a [prepared statement]
4118** object back to its initial state, ready to be re-executed.
4119** ^Any SQL statement variables that had values bound to them using
4120** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
4121** Use [sqlite3_clear_bindings()] to reset the bindings.
4122**
4123** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S
4124** back to the beginning of its program.
4125**
4126** ^If the most recent call to [sqlite3_step(S)] for the
4127** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
4128** or if [sqlite3_step(S)] has never before been called on S,
4129** then [sqlite3_reset(S)] returns [SQLITE_OK].
4130**
4131** ^If the most recent call to [sqlite3_step(S)] for the
4132** [prepared statement] S indicated an error, then
4133** [sqlite3_reset(S)] returns an appropriate [error code].
4134**
4135** ^The [sqlite3_reset(S)] interface does not change the values
4136** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
4137*/
4138SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
4139
4140/*
4141** CAPI3REF: Create Or Redefine SQL Functions
4142** KEYWORDS: {function creation routines}
4143** KEYWORDS: {application-defined SQL function}
4144** KEYWORDS: {application-defined SQL functions}
4145**
4146** ^These functions (collectively known as "function creation routines")
4147** are used to add SQL functions or aggregates or to redefine the behavior
4148** of existing SQL functions or aggregates.  The only differences between
4149** these routines are the text encoding expected for
4150** the second parameter (the name of the function being created)
4151** and the presence or absence of a destructor callback for
4152** the application data pointer.
4153**
4154** ^The first parameter is the [database connection] to which the SQL
4155** function is to be added.  ^If an application uses more than one database
4156** connection then application-defined SQL functions must be added
4157** to each database connection separately.
4158**
4159** ^The second parameter is the name of the SQL function to be created or
4160** redefined.  ^The length of the name is limited to 255 bytes in a UTF-8
4161** representation, exclusive of the zero-terminator.  ^Note that the name
4162** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
4163** ^Any attempt to create a function with a longer name
4164** will result in [SQLITE_MISUSE] being returned.
4165**
4166** ^The third parameter (nArg)
4167** is the number of arguments that the SQL function or
4168** aggregate takes. ^If this parameter is -1, then the SQL function or
4169** aggregate may take any number of arguments between 0 and the limit
4170** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]).  If the third
4171** parameter is less than -1 or greater than 127 then the behavior is
4172** undefined.
4173**
4174** ^The fourth parameter, eTextRep, specifies what
4175** [SQLITE_UTF8 | text encoding] this SQL function prefers for
4176** its parameters.  The application should set this parameter to
4177** [SQLITE_UTF16LE] if the function implementation invokes
4178** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the
4179** implementation invokes [sqlite3_value_text16be()] on an input, or
4180** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8]
4181** otherwise.  ^The same SQL function may be registered multiple times using
4182** different preferred text encodings, with different implementations for
4183** each encoding.
4184** ^When multiple implementations of the same function are available, SQLite
4185** will pick the one that involves the least amount of data conversion.
4186**
4187** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC]
4188** to signal that the function will always return the same result given
4189** the same inputs within a single SQL statement.  Most SQL functions are
4190** deterministic.  The built-in [random()] SQL function is an example of a
4191** function that is not deterministic.  The SQLite query planner is able to
4192** perform additional optimizations on deterministic functions, so use
4193** of the [SQLITE_DETERMINISTIC] flag is recommended where possible.
4194**
4195** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
4196** function can gain access to this pointer using [sqlite3_user_data()].)^
4197**
4198** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are
4199** pointers to C-language functions that implement the SQL function or
4200** aggregate. ^A scalar SQL function requires an implementation of the xFunc
4201** callback only; NULL pointers must be passed as the xStep and xFinal
4202** parameters. ^An aggregate SQL function requires an implementation of xStep
4203** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
4204** SQL function or aggregate, pass NULL pointers for all three function
4205** callbacks.
4206**
4207** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
4208** then it is destructor for the application data pointer.
4209** The destructor is invoked when the function is deleted, either by being
4210** overloaded or when the database connection closes.)^
4211** ^The destructor is also invoked if the call to
4212** sqlite3_create_function_v2() fails.
4213** ^When the destructor callback of the tenth parameter is invoked, it
4214** is passed a single argument which is a copy of the application data
4215** pointer which was the fifth parameter to sqlite3_create_function_v2().
4216**
4217** ^It is permitted to register multiple implementations of the same
4218** functions with the same name but with either differing numbers of
4219** arguments or differing preferred text encodings.  ^SQLite will use
4220** the implementation that most closely matches the way in which the
4221** SQL function is used.  ^A function implementation with a non-negative
4222** nArg parameter is a better match than a function implementation with
4223** a negative nArg.  ^A function where the preferred text encoding
4224** matches the database encoding is a better
4225** match than a function where the encoding is different.
4226** ^A function where the encoding difference is between UTF16le and UTF16be
4227** is a closer match than a function where the encoding difference is
4228** between UTF8 and UTF16.
4229**
4230** ^Built-in functions may be overloaded by new application-defined functions.
4231**
4232** ^An application-defined function is permitted to call other
4233** SQLite interfaces.  However, such calls must not
4234** close the database connection nor finalize or reset the prepared
4235** statement in which the function is running.
4236*/
4237SQLITE_API int sqlite3_create_function(
4238  sqlite3 *db,
4239  const char *zFunctionName,
4240  int nArg,
4241  int eTextRep,
4242  void *pApp,
4243  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4244  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4245  void (*xFinal)(sqlite3_context*)
4246);
4247SQLITE_API int sqlite3_create_function16(
4248  sqlite3 *db,
4249  const void *zFunctionName,
4250  int nArg,
4251  int eTextRep,
4252  void *pApp,
4253  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4254  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4255  void (*xFinal)(sqlite3_context*)
4256);
4257SQLITE_API int sqlite3_create_function_v2(
4258  sqlite3 *db,
4259  const char *zFunctionName,
4260  int nArg,
4261  int eTextRep,
4262  void *pApp,
4263  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4264  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4265  void (*xFinal)(sqlite3_context*),
4266  void(*xDestroy)(void*)
4267);
4268
4269/*
4270** CAPI3REF: Text Encodings
4271**
4272** These constant define integer codes that represent the various
4273** text encodings supported by SQLite.
4274*/
4275#define SQLITE_UTF8           1
4276#define SQLITE_UTF16LE        2
4277#define SQLITE_UTF16BE        3
4278#define SQLITE_UTF16          4    /* Use native byte order */
4279#define SQLITE_ANY            5    /* Deprecated */
4280#define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
4281
4282/*
4283** CAPI3REF: Function Flags
4284**
4285** These constants may be ORed together with the
4286** [SQLITE_UTF8 | preferred text encoding] as the fourth argument
4287** to [sqlite3_create_function()], [sqlite3_create_function16()], or
4288** [sqlite3_create_function_v2()].
4289*/
4290#define SQLITE_DETERMINISTIC    0x800
4291
4292/*
4293** CAPI3REF: Deprecated Functions
4294** DEPRECATED
4295**
4296** These functions are [deprecated].  In order to maintain
4297** backwards compatibility with older code, these functions continue
4298** to be supported.  However, new applications should avoid
4299** the use of these functions.  To help encourage people to avoid
4300** using these functions, we are not going to tell you what they do.
4301*/
4302#ifndef SQLITE_OMIT_DEPRECATED
4303SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
4304SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
4305SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
4306SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
4307SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
4308SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
4309                      void*,sqlite3_int64);
4310#endif
4311
4312/*
4313** CAPI3REF: Obtaining SQL Function Parameter Values
4314**
4315** The C-language implementation of SQL functions and aggregates uses
4316** this set of interface routines to access the parameter values on
4317** the function or aggregate.
4318**
4319** The xFunc (for scalar functions) or xStep (for aggregates) parameters
4320** to [sqlite3_create_function()] and [sqlite3_create_function16()]
4321** define callbacks that implement the SQL functions and aggregates.
4322** The 3rd parameter to these callbacks is an array of pointers to
4323** [protected sqlite3_value] objects.  There is one [sqlite3_value] object for
4324** each parameter to the SQL function.  These routines are used to
4325** extract values from the [sqlite3_value] objects.
4326**
4327** These routines work only with [protected sqlite3_value] objects.
4328** Any attempt to use these routines on an [unprotected sqlite3_value]
4329** object results in undefined behavior.
4330**
4331** ^These routines work just like the corresponding [column access functions]
4332** except that these routines take a single [protected sqlite3_value] object
4333** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
4334**
4335** ^The sqlite3_value_text16() interface extracts a UTF-16 string
4336** in the native byte-order of the host machine.  ^The
4337** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
4338** extract UTF-16 strings as big-endian and little-endian respectively.
4339**
4340** ^(The sqlite3_value_numeric_type() interface attempts to apply
4341** numeric affinity to the value.  This means that an attempt is
4342** made to convert the value to an integer or floating point.  If
4343** such a conversion is possible without loss of information (in other
4344** words, if the value is a string that looks like a number)
4345** then the conversion is performed.  Otherwise no conversion occurs.
4346** The [SQLITE_INTEGER | datatype] after conversion is returned.)^
4347**
4348** Please pay particular attention to the fact that the pointer returned
4349** from [sqlite3_value_blob()], [sqlite3_value_text()], or
4350** [sqlite3_value_text16()] can be invalidated by a subsequent call to
4351** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
4352** or [sqlite3_value_text16()].
4353**
4354** These routines must be called from the same thread as
4355** the SQL function that supplied the [sqlite3_value*] parameters.
4356*/
4357SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
4358SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
4359SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
4360SQLITE_API double sqlite3_value_double(sqlite3_value*);
4361SQLITE_API int sqlite3_value_int(sqlite3_value*);
4362SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
4363SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
4364SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
4365SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
4366SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
4367SQLITE_API int sqlite3_value_type(sqlite3_value*);
4368SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
4369
4370/*
4371** CAPI3REF: Obtain Aggregate Function Context
4372**
4373** Implementations of aggregate SQL functions use this
4374** routine to allocate memory for storing their state.
4375**
4376** ^The first time the sqlite3_aggregate_context(C,N) routine is called
4377** for a particular aggregate function, SQLite
4378** allocates N of memory, zeroes out that memory, and returns a pointer
4379** to the new memory. ^On second and subsequent calls to
4380** sqlite3_aggregate_context() for the same aggregate function instance,
4381** the same buffer is returned.  Sqlite3_aggregate_context() is normally
4382** called once for each invocation of the xStep callback and then one
4383** last time when the xFinal callback is invoked.  ^(When no rows match
4384** an aggregate query, the xStep() callback of the aggregate function
4385** implementation is never called and xFinal() is called exactly once.
4386** In those cases, sqlite3_aggregate_context() might be called for the
4387** first time from within xFinal().)^
4388**
4389** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer
4390** when first called if N is less than or equal to zero or if a memory
4391** allocate error occurs.
4392**
4393** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
4394** determined by the N parameter on first successful call.  Changing the
4395** value of N in subsequent call to sqlite3_aggregate_context() within
4396** the same aggregate function instance will not resize the memory
4397** allocation.)^  Within the xFinal callback, it is customary to set
4398** N=0 in calls to sqlite3_aggregate_context(C,N) so that no
4399** pointless memory allocations occur.
4400**
4401** ^SQLite automatically frees the memory allocated by
4402** sqlite3_aggregate_context() when the aggregate query concludes.
4403**
4404** The first parameter must be a copy of the
4405** [sqlite3_context | SQL function context] that is the first parameter
4406** to the xStep or xFinal callback routine that implements the aggregate
4407** function.
4408**
4409** This routine must be called from the same thread in which
4410** the aggregate SQL function is running.
4411*/
4412SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
4413
4414/*
4415** CAPI3REF: User Data For Functions
4416**
4417** ^The sqlite3_user_data() interface returns a copy of
4418** the pointer that was the pUserData parameter (the 5th parameter)
4419** of the [sqlite3_create_function()]
4420** and [sqlite3_create_function16()] routines that originally
4421** registered the application defined function.
4422**
4423** This routine must be called from the same thread in which
4424** the application-defined function is running.
4425*/
4426SQLITE_API void *sqlite3_user_data(sqlite3_context*);
4427
4428/*
4429** CAPI3REF: Database Connection For Functions
4430**
4431** ^The sqlite3_context_db_handle() interface returns a copy of
4432** the pointer to the [database connection] (the 1st parameter)
4433** of the [sqlite3_create_function()]
4434** and [sqlite3_create_function16()] routines that originally
4435** registered the application defined function.
4436*/
4437SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
4438
4439/*
4440** CAPI3REF: Function Auxiliary Data
4441**
4442** These functions may be used by (non-aggregate) SQL functions to
4443** associate metadata with argument values. If the same value is passed to
4444** multiple invocations of the same SQL function during query execution, under
4445** some circumstances the associated metadata may be preserved.  An example
4446** of where this might be useful is in a regular-expression matching
4447** function. The compiled version of the regular expression can be stored as
4448** metadata associated with the pattern string.
4449** Then as long as the pattern string remains the same,
4450** the compiled regular expression can be reused on multiple
4451** invocations of the same function.
4452**
4453** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata
4454** associated by the sqlite3_set_auxdata() function with the Nth argument
4455** value to the application-defined function. ^If there is no metadata
4456** associated with the function argument, this sqlite3_get_auxdata() interface
4457** returns a NULL pointer.
4458**
4459** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th
4460** argument of the application-defined function.  ^Subsequent
4461** calls to sqlite3_get_auxdata(C,N) return P from the most recent
4462** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or
4463** NULL if the metadata has been discarded.
4464** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL,
4465** SQLite will invoke the destructor function X with parameter P exactly
4466** once, when the metadata is discarded.
4467** SQLite is free to discard the metadata at any time, including: <ul>
4468** <li> when the corresponding function parameter changes, or
4469** <li> when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
4470**      SQL statement, or
4471** <li> when sqlite3_set_auxdata() is invoked again on the same parameter, or
4472** <li> during the original sqlite3_set_auxdata() call when a memory
4473**      allocation error occurs. </ul>)^
4474**
4475** Note the last bullet in particular.  The destructor X in
4476** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
4477** sqlite3_set_auxdata() interface even returns.  Hence sqlite3_set_auxdata()
4478** should be called near the end of the function implementation and the
4479** function implementation should not make any use of P after
4480** sqlite3_set_auxdata() has been called.
4481**
4482** ^(In practice, metadata is preserved between function calls for
4483** function parameters that are compile-time constants, including literal
4484** values and [parameters] and expressions composed from the same.)^
4485**
4486** These routines must be called from the same thread in which
4487** the SQL function is running.
4488*/
4489SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
4490SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
4491
4492
4493/*
4494** CAPI3REF: Constants Defining Special Destructor Behavior
4495**
4496** These are special values for the destructor that is passed in as the
4497** final argument to routines like [sqlite3_result_blob()].  ^If the destructor
4498** argument is SQLITE_STATIC, it means that the content pointer is constant
4499** and will never change.  It does not need to be destroyed.  ^The
4500** SQLITE_TRANSIENT value means that the content will likely change in
4501** the near future and that SQLite should make its own private copy of
4502** the content before returning.
4503**
4504** The typedef is necessary to work around problems in certain
4505** C++ compilers.
4506*/
4507typedef void (*sqlite3_destructor_type)(void*);
4508#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
4509#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
4510
4511/*
4512** CAPI3REF: Setting The Result Of An SQL Function
4513**
4514** These routines are used by the xFunc or xFinal callbacks that
4515** implement SQL functions and aggregates.  See
4516** [sqlite3_create_function()] and [sqlite3_create_function16()]
4517** for additional information.
4518**
4519** These functions work very much like the [parameter binding] family of
4520** functions used to bind values to host parameters in prepared statements.
4521** Refer to the [SQL parameter] documentation for additional information.
4522**
4523** ^The sqlite3_result_blob() interface sets the result from
4524** an application-defined function to be the BLOB whose content is pointed
4525** to by the second parameter and which is N bytes long where N is the
4526** third parameter.
4527**
4528** ^The sqlite3_result_zeroblob() interfaces set the result of
4529** the application-defined function to be a BLOB containing all zero
4530** bytes and N bytes in size, where N is the value of the 2nd parameter.
4531**
4532** ^The sqlite3_result_double() interface sets the result from
4533** an application-defined function to be a floating point value specified
4534** by its 2nd argument.
4535**
4536** ^The sqlite3_result_error() and sqlite3_result_error16() functions
4537** cause the implemented SQL function to throw an exception.
4538** ^SQLite uses the string pointed to by the
4539** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
4540** as the text of an error message.  ^SQLite interprets the error
4541** message string from sqlite3_result_error() as UTF-8. ^SQLite
4542** interprets the string from sqlite3_result_error16() as UTF-16 in native
4543** byte order.  ^If the third parameter to sqlite3_result_error()
4544** or sqlite3_result_error16() is negative then SQLite takes as the error
4545** message all text up through the first zero character.
4546** ^If the third parameter to sqlite3_result_error() or
4547** sqlite3_result_error16() is non-negative then SQLite takes that many
4548** bytes (not characters) from the 2nd parameter as the error message.
4549** ^The sqlite3_result_error() and sqlite3_result_error16()
4550** routines make a private copy of the error message text before
4551** they return.  Hence, the calling function can deallocate or
4552** modify the text after they return without harm.
4553** ^The sqlite3_result_error_code() function changes the error code
4554** returned by SQLite as a result of an error in a function.  ^By default,
4555** the error code is SQLITE_ERROR.  ^A subsequent call to sqlite3_result_error()
4556** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
4557**
4558** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an
4559** error indicating that a string or BLOB is too long to represent.
4560**
4561** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an
4562** error indicating that a memory allocation failed.
4563**
4564** ^The sqlite3_result_int() interface sets the return value
4565** of the application-defined function to be the 32-bit signed integer
4566** value given in the 2nd argument.
4567** ^The sqlite3_result_int64() interface sets the return value
4568** of the application-defined function to be the 64-bit signed integer
4569** value given in the 2nd argument.
4570**
4571** ^The sqlite3_result_null() interface sets the return value
4572** of the application-defined function to be NULL.
4573**
4574** ^The sqlite3_result_text(), sqlite3_result_text16(),
4575** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
4576** set the return value of the application-defined function to be
4577** a text string which is represented as UTF-8, UTF-16 native byte order,
4578** UTF-16 little endian, or UTF-16 big endian, respectively.
4579** ^The sqlite3_result_text64() interface sets the return value of an
4580** application-defined function to be a text string in an encoding
4581** specified by the fifth (and last) parameter, which must be one
4582** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE].
4583** ^SQLite takes the text result from the application from
4584** the 2nd parameter of the sqlite3_result_text* interfaces.
4585** ^If the 3rd parameter to the sqlite3_result_text* interfaces
4586** is negative, then SQLite takes result text from the 2nd parameter
4587** through the first zero character.
4588** ^If the 3rd parameter to the sqlite3_result_text* interfaces
4589** is non-negative, then as many bytes (not characters) of the text
4590** pointed to by the 2nd parameter are taken as the application-defined
4591** function result.  If the 3rd parameter is non-negative, then it
4592** must be the byte offset into the string where the NUL terminator would
4593** appear if the string where NUL terminated.  If any NUL characters occur
4594** in the string at a byte offset that is less than the value of the 3rd
4595** parameter, then the resulting string will contain embedded NULs and the
4596** result of expressions operating on strings with embedded NULs is undefined.
4597** ^If the 4th parameter to the sqlite3_result_text* interfaces
4598** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
4599** function as the destructor on the text or BLOB result when it has
4600** finished using that result.
4601** ^If the 4th parameter to the sqlite3_result_text* interfaces or to
4602** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
4603** assumes that the text or BLOB result is in constant space and does not
4604** copy the content of the parameter nor call a destructor on the content
4605** when it has finished using that result.
4606** ^If the 4th parameter to the sqlite3_result_text* interfaces
4607** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
4608** then SQLite makes a copy of the result into space obtained from
4609** from [sqlite3_malloc()] before it returns.
4610**
4611** ^The sqlite3_result_value() interface sets the result of
4612** the application-defined function to be a copy the
4613** [unprotected sqlite3_value] object specified by the 2nd parameter.  ^The
4614** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
4615** so that the [sqlite3_value] specified in the parameter may change or
4616** be deallocated after sqlite3_result_value() returns without harm.
4617** ^A [protected sqlite3_value] object may always be used where an
4618** [unprotected sqlite3_value] object is required, so either
4619** kind of [sqlite3_value] object can be used with this interface.
4620**
4621** If these routines are called from within the different thread
4622** than the one containing the application-defined function that received
4623** the [sqlite3_context] pointer, the results are undefined.
4624*/
4625SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
4626SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*,sqlite3_uint64,void(*)(void*));
4627SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
4628SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
4629SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
4630SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
4631SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
4632SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
4633SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
4634SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
4635SQLITE_API void sqlite3_result_null(sqlite3_context*);
4636SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
4637SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
4638                           void(*)(void*), unsigned char encoding);
4639SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
4640SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
4641SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
4642SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
4643SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
4644
4645/*
4646** CAPI3REF: Define New Collating Sequences
4647**
4648** ^These functions add, remove, or modify a [collation] associated
4649** with the [database connection] specified as the first argument.
4650**
4651** ^The name of the collation is a UTF-8 string
4652** for sqlite3_create_collation() and sqlite3_create_collation_v2()
4653** and a UTF-16 string in native byte order for sqlite3_create_collation16().
4654** ^Collation names that compare equal according to [sqlite3_strnicmp()] are
4655** considered to be the same name.
4656**
4657** ^(The third argument (eTextRep) must be one of the constants:
4658** <ul>
4659** <li> [SQLITE_UTF8],
4660** <li> [SQLITE_UTF16LE],
4661** <li> [SQLITE_UTF16BE],
4662** <li> [SQLITE_UTF16], or
4663** <li> [SQLITE_UTF16_ALIGNED].
4664** </ul>)^
4665** ^The eTextRep argument determines the encoding of strings passed
4666** to the collating function callback, xCallback.
4667** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep
4668** force strings to be UTF16 with native byte order.
4669** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin
4670** on an even byte address.
4671**
4672** ^The fourth argument, pArg, is an application data pointer that is passed
4673** through as the first argument to the collating function callback.
4674**
4675** ^The fifth argument, xCallback, is a pointer to the collating function.
4676** ^Multiple collating functions can be registered using the same name but
4677** with different eTextRep parameters and SQLite will use whichever
4678** function requires the least amount of data transformation.
4679** ^If the xCallback argument is NULL then the collating function is
4680** deleted.  ^When all collating functions having the same name are deleted,
4681** that collation is no longer usable.
4682**
4683** ^The collating function callback is invoked with a copy of the pArg
4684** application data pointer and with two strings in the encoding specified
4685** by the eTextRep argument.  The collating function must return an
4686** integer that is negative, zero, or positive
4687** if the first string is less than, equal to, or greater than the second,
4688** respectively.  A collating function must always return the same answer
4689** given the same inputs.  If two or more collating functions are registered
4690** to the same collation name (using different eTextRep values) then all
4691** must give an equivalent answer when invoked with equivalent strings.
4692** The collating function must obey the following properties for all
4693** strings A, B, and C:
4694**
4695** <ol>
4696** <li> If A==B then B==A.
4697** <li> If A==B and B==C then A==C.
4698** <li> If A&lt;B THEN B&gt;A.
4699** <li> If A&lt;B and B&lt;C then A&lt;C.
4700** </ol>
4701**
4702** If a collating function fails any of the above constraints and that
4703** collating function is  registered and used, then the behavior of SQLite
4704** is undefined.
4705**
4706** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation()
4707** with the addition that the xDestroy callback is invoked on pArg when
4708** the collating function is deleted.
4709** ^Collating functions are deleted when they are overridden by later
4710** calls to the collation creation functions or when the
4711** [database connection] is closed using [sqlite3_close()].
4712**
4713** ^The xDestroy callback is <u>not</u> called if the
4714** sqlite3_create_collation_v2() function fails.  Applications that invoke
4715** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should
4716** check the return code and dispose of the application data pointer
4717** themselves rather than expecting SQLite to deal with it for them.
4718** This is different from every other SQLite interface.  The inconsistency
4719** is unfortunate but cannot be changed without breaking backwards
4720** compatibility.
4721**
4722** See also:  [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
4723*/
4724SQLITE_API int sqlite3_create_collation(
4725  sqlite3*,
4726  const char *zName,
4727  int eTextRep,
4728  void *pArg,
4729  int(*xCompare)(void*,int,const void*,int,const void*)
4730);
4731SQLITE_API int sqlite3_create_collation_v2(
4732  sqlite3*,
4733  const char *zName,
4734  int eTextRep,
4735  void *pArg,
4736  int(*xCompare)(void*,int,const void*,int,const void*),
4737  void(*xDestroy)(void*)
4738);
4739SQLITE_API int sqlite3_create_collation16(
4740  sqlite3*,
4741  const void *zName,
4742  int eTextRep,
4743  void *pArg,
4744  int(*xCompare)(void*,int,const void*,int,const void*)
4745);
4746
4747/*
4748** CAPI3REF: Collation Needed Callbacks
4749**
4750** ^To avoid having to register all collation sequences before a database
4751** can be used, a single callback function may be registered with the
4752** [database connection] to be invoked whenever an undefined collation
4753** sequence is required.
4754**
4755** ^If the function is registered using the sqlite3_collation_needed() API,
4756** then it is passed the names of undefined collation sequences as strings
4757** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
4758** the names are passed as UTF-16 in machine native byte order.
4759** ^A call to either function replaces the existing collation-needed callback.
4760**
4761** ^(When the callback is invoked, the first argument passed is a copy
4762** of the second argument to sqlite3_collation_needed() or
4763** sqlite3_collation_needed16().  The second argument is the database
4764** connection.  The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE],
4765** or [SQLITE_UTF16LE], indicating the most desirable form of the collation
4766** sequence function required.  The fourth parameter is the name of the
4767** required collation sequence.)^
4768**
4769** The callback function should register the desired collation using
4770** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
4771** [sqlite3_create_collation_v2()].
4772*/
4773SQLITE_API int sqlite3_collation_needed(
4774  sqlite3*,
4775  void*,
4776  void(*)(void*,sqlite3*,int eTextRep,const char*)
4777);
4778SQLITE_API int sqlite3_collation_needed16(
4779  sqlite3*,
4780  void*,
4781  void(*)(void*,sqlite3*,int eTextRep,const void*)
4782);
4783
4784#ifdef SQLITE_HAS_CODEC
4785/*
4786** Specify the key for an encrypted database.  This routine should be
4787** called right after sqlite3_open().
4788**
4789** The code to implement this API is not available in the public release
4790** of SQLite.
4791*/
4792SQLITE_API int sqlite3_key(
4793  sqlite3 *db,                   /* Database to be rekeyed */
4794  const void *pKey, int nKey     /* The key */
4795);
4796SQLITE_API int sqlite3_key_v2(
4797  sqlite3 *db,                   /* Database to be rekeyed */
4798  const char *zDbName,           /* Name of the database */
4799  const void *pKey, int nKey     /* The key */
4800);
4801
4802/*
4803** Change the key on an open database.  If the current database is not
4804** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
4805** database is decrypted.
4806**
4807** The code to implement this API is not available in the public release
4808** of SQLite.
4809*/
4810SQLITE_API int sqlite3_rekey(
4811  sqlite3 *db,                   /* Database to be rekeyed */
4812  const void *pKey, int nKey     /* The new key */
4813);
4814SQLITE_API int sqlite3_rekey_v2(
4815  sqlite3 *db,                   /* Database to be rekeyed */
4816  const char *zDbName,           /* Name of the database */
4817  const void *pKey, int nKey     /* The new key */
4818);
4819
4820/*
4821** Specify the activation key for a SEE database.  Unless
4822** activated, none of the SEE routines will work.
4823*/
4824SQLITE_API void sqlite3_activate_see(
4825  const char *zPassPhrase        /* Activation phrase */
4826);
4827#endif
4828
4829#ifdef SQLITE_ENABLE_CEROD
4830/*
4831** Specify the activation key for a CEROD database.  Unless
4832** activated, none of the CEROD routines will work.
4833*/
4834SQLITE_API void sqlite3_activate_cerod(
4835  const char *zPassPhrase        /* Activation phrase */
4836);
4837#endif
4838
4839/*
4840** CAPI3REF: Suspend Execution For A Short Time
4841**
4842** The sqlite3_sleep() function causes the current thread to suspend execution
4843** for at least a number of milliseconds specified in its parameter.
4844**
4845** If the operating system does not support sleep requests with
4846** millisecond time resolution, then the time will be rounded up to
4847** the nearest second. The number of milliseconds of sleep actually
4848** requested from the operating system is returned.
4849**
4850** ^SQLite implements this interface by calling the xSleep()
4851** method of the default [sqlite3_vfs] object.  If the xSleep() method
4852** of the default VFS is not implemented correctly, or not implemented at
4853** all, then the behavior of sqlite3_sleep() may deviate from the description
4854** in the previous paragraphs.
4855*/
4856SQLITE_API int sqlite3_sleep(int);
4857
4858/*
4859** CAPI3REF: Name Of The Folder Holding Temporary Files
4860**
4861** ^(If this global variable is made to point to a string which is
4862** the name of a folder (a.k.a. directory), then all temporary files
4863** created by SQLite when using a built-in [sqlite3_vfs | VFS]
4864** will be placed in that directory.)^  ^If this variable
4865** is a NULL pointer, then SQLite performs a search for an appropriate
4866** temporary file directory.
4867**
4868** Applications are strongly discouraged from using this global variable.
4869** It is required to set a temporary folder on Windows Runtime (WinRT).
4870** But for all other platforms, it is highly recommended that applications
4871** neither read nor write this variable.  This global variable is a relic
4872** that exists for backwards compatibility of legacy applications and should
4873** be avoided in new projects.
4874**
4875** It is not safe to read or modify this variable in more than one
4876** thread at a time.  It is not safe to read or modify this variable
4877** if a [database connection] is being used at the same time in a separate
4878** thread.
4879** It is intended that this variable be set once
4880** as part of process initialization and before any SQLite interface
4881** routines have been called and that this variable remain unchanged
4882** thereafter.
4883**
4884** ^The [temp_store_directory pragma] may modify this variable and cause
4885** it to point to memory obtained from [sqlite3_malloc].  ^Furthermore,
4886** the [temp_store_directory pragma] always assumes that any string
4887** that this variable points to is held in memory obtained from
4888** [sqlite3_malloc] and the pragma may attempt to free that memory
4889** using [sqlite3_free].
4890** Hence, if this variable is modified directly, either it should be
4891** made NULL or made to point to memory obtained from [sqlite3_malloc]
4892** or else the use of the [temp_store_directory pragma] should be avoided.
4893** Except when requested by the [temp_store_directory pragma], SQLite
4894** does not free the memory that sqlite3_temp_directory points to.  If
4895** the application wants that memory to be freed, it must do
4896** so itself, taking care to only do so after all [database connection]
4897** objects have been destroyed.
4898**
4899** <b>Note to Windows Runtime users:</b>  The temporary directory must be set
4900** prior to calling [sqlite3_open] or [sqlite3_open_v2].  Otherwise, various
4901** features that require the use of temporary files may fail.  Here is an
4902** example of how to do this using C++ with the Windows Runtime:
4903**
4904** <blockquote><pre>
4905** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
4906** &nbsp;     TemporaryFolder->Path->Data();
4907** char zPathBuf&#91;MAX_PATH + 1&#93;;
4908** memset(zPathBuf, 0, sizeof(zPathBuf));
4909** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
4910** &nbsp;     NULL, NULL);
4911** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
4912** </pre></blockquote>
4913*/
4914SQLITE_API char *sqlite3_temp_directory;
4915
4916/*
4917** CAPI3REF: Name Of The Folder Holding Database Files
4918**
4919** ^(If this global variable is made to point to a string which is
4920** the name of a folder (a.k.a. directory), then all database files
4921** specified with a relative pathname and created or accessed by
4922** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
4923** to be relative to that directory.)^ ^If this variable is a NULL
4924** pointer, then SQLite assumes that all database files specified
4925** with a relative pathname are relative to the current directory
4926** for the process.  Only the windows VFS makes use of this global
4927** variable; it is ignored by the unix VFS.
4928**
4929** Changing the value of this variable while a database connection is
4930** open can result in a corrupt database.
4931**
4932** It is not safe to read or modify this variable in more than one
4933** thread at a time.  It is not safe to read or modify this variable
4934** if a [database connection] is being used at the same time in a separate
4935** thread.
4936** It is intended that this variable be set once
4937** as part of process initialization and before any SQLite interface
4938** routines have been called and that this variable remain unchanged
4939** thereafter.
4940**
4941** ^The [data_store_directory pragma] may modify this variable and cause
4942** it to point to memory obtained from [sqlite3_malloc].  ^Furthermore,
4943** the [data_store_directory pragma] always assumes that any string
4944** that this variable points to is held in memory obtained from
4945** [sqlite3_malloc] and the pragma may attempt to free that memory
4946** using [sqlite3_free].
4947** Hence, if this variable is modified directly, either it should be
4948** made NULL or made to point to memory obtained from [sqlite3_malloc]
4949** or else the use of the [data_store_directory pragma] should be avoided.
4950*/
4951SQLITE_API char *sqlite3_data_directory;
4952
4953/*
4954** CAPI3REF: Test For Auto-Commit Mode
4955** KEYWORDS: {autocommit mode}
4956**
4957** ^The sqlite3_get_autocommit() interface returns non-zero or
4958** zero if the given database connection is or is not in autocommit mode,
4959** respectively.  ^Autocommit mode is on by default.
4960** ^Autocommit mode is disabled by a [BEGIN] statement.
4961** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
4962**
4963** If certain kinds of errors occur on a statement within a multi-statement
4964** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
4965** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
4966** transaction might be rolled back automatically.  The only way to
4967** find out whether SQLite automatically rolled back the transaction after
4968** an error is to use this function.
4969**
4970** If another thread changes the autocommit status of the database
4971** connection while this routine is running, then the return value
4972** is undefined.
4973*/
4974SQLITE_API int sqlite3_get_autocommit(sqlite3*);
4975
4976/*
4977** CAPI3REF: Find The Database Handle Of A Prepared Statement
4978**
4979** ^The sqlite3_db_handle interface returns the [database connection] handle
4980** to which a [prepared statement] belongs.  ^The [database connection]
4981** returned by sqlite3_db_handle is the same [database connection]
4982** that was the first argument
4983** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
4984** create the statement in the first place.
4985*/
4986SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
4987
4988/*
4989** CAPI3REF: Return The Filename For A Database Connection
4990**
4991** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename
4992** associated with database N of connection D.  ^The main database file
4993** has the name "main".  If there is no attached database N on the database
4994** connection D, or if database N is a temporary or in-memory database, then
4995** a NULL pointer is returned.
4996**
4997** ^The filename returned by this function is the output of the
4998** xFullPathname method of the [VFS].  ^In other words, the filename
4999** will be an absolute pathname, even if the filename used
5000** to open the database originally was a URI or relative pathname.
5001*/
5002SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
5003
5004/*
5005** CAPI3REF: Determine if a database is read-only
5006**
5007** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N
5008** of connection D is read-only, 0 if it is read/write, or -1 if N is not
5009** the name of a database on connection D.
5010*/
5011SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
5012
5013/*
5014** CAPI3REF: Find the next prepared statement
5015**
5016** ^This interface returns a pointer to the next [prepared statement] after
5017** pStmt associated with the [database connection] pDb.  ^If pStmt is NULL
5018** then this interface returns a pointer to the first prepared statement
5019** associated with the database connection pDb.  ^If no prepared statement
5020** satisfies the conditions of this routine, it returns NULL.
5021**
5022** The [database connection] pointer D in a call to
5023** [sqlite3_next_stmt(D,S)] must refer to an open database
5024** connection and in particular must not be a NULL pointer.
5025*/
5026SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
5027
5028/*
5029** CAPI3REF: Commit And Rollback Notification Callbacks
5030**
5031** ^The sqlite3_commit_hook() interface registers a callback
5032** function to be invoked whenever a transaction is [COMMIT | committed].
5033** ^Any callback set by a previous call to sqlite3_commit_hook()
5034** for the same database connection is overridden.
5035** ^The sqlite3_rollback_hook() interface registers a callback
5036** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
5037** ^Any callback set by a previous call to sqlite3_rollback_hook()
5038** for the same database connection is overridden.
5039** ^The pArg argument is passed through to the callback.
5040** ^If the callback on a commit hook function returns non-zero,
5041** then the commit is converted into a rollback.
5042**
5043** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
5044** return the P argument from the previous call of the same function
5045** on the same [database connection] D, or NULL for
5046** the first call for each function on D.
5047**
5048** The commit and rollback hook callbacks are not reentrant.
5049** The callback implementation must not do anything that will modify
5050** the database connection that invoked the callback.  Any actions
5051** to modify the database connection must be deferred until after the
5052** completion of the [sqlite3_step()] call that triggered the commit
5053** or rollback hook in the first place.
5054** Note that running any other SQL statements, including SELECT statements,
5055** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
5056** the database connections for the meaning of "modify" in this paragraph.
5057**
5058** ^Registering a NULL function disables the callback.
5059**
5060** ^When the commit hook callback routine returns zero, the [COMMIT]
5061** operation is allowed to continue normally.  ^If the commit hook
5062** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
5063** ^The rollback hook is invoked on a rollback that results from a commit
5064** hook returning non-zero, just as it would be with any other rollback.
5065**
5066** ^For the purposes of this API, a transaction is said to have been
5067** rolled back if an explicit "ROLLBACK" statement is executed, or
5068** an error or constraint causes an implicit rollback to occur.
5069** ^The rollback callback is not invoked if a transaction is
5070** automatically rolled back because the database connection is closed.
5071**
5072** See also the [sqlite3_update_hook()] interface.
5073*/
5074SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
5075SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
5076
5077/*
5078** CAPI3REF: Data Change Notification Callbacks
5079**
5080** ^The sqlite3_update_hook() interface registers a callback function
5081** with the [database connection] identified by the first argument
5082** to be invoked whenever a row is updated, inserted or deleted in
5083** a rowid table.
5084** ^Any callback set by a previous call to this function
5085** for the same database connection is overridden.
5086**
5087** ^The second argument is a pointer to the function to invoke when a
5088** row is updated, inserted or deleted in a rowid table.
5089** ^The first argument to the callback is a copy of the third argument
5090** to sqlite3_update_hook().
5091** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
5092** or [SQLITE_UPDATE], depending on the operation that caused the callback
5093** to be invoked.
5094** ^The third and fourth arguments to the callback contain pointers to the
5095** database and table name containing the affected row.
5096** ^The final callback parameter is the [rowid] of the row.
5097** ^In the case of an update, this is the [rowid] after the update takes place.
5098**
5099** ^(The update hook is not invoked when internal system tables are
5100** modified (i.e. sqlite_master and sqlite_sequence).)^
5101** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified.
5102**
5103** ^In the current implementation, the update hook
5104** is not invoked when duplication rows are deleted because of an
5105** [ON CONFLICT | ON CONFLICT REPLACE] clause.  ^Nor is the update hook
5106** invoked when rows are deleted using the [truncate optimization].
5107** The exceptions defined in this paragraph might change in a future
5108** release of SQLite.
5109**
5110** The update hook implementation must not do anything that will modify
5111** the database connection that invoked the update hook.  Any actions
5112** to modify the database connection must be deferred until after the
5113** completion of the [sqlite3_step()] call that triggered the update hook.
5114** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
5115** database connections for the meaning of "modify" in this paragraph.
5116**
5117** ^The sqlite3_update_hook(D,C,P) function
5118** returns the P argument from the previous call
5119** on the same [database connection] D, or NULL for
5120** the first call on D.
5121**
5122** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
5123** interfaces.
5124*/
5125SQLITE_API void *sqlite3_update_hook(
5126  sqlite3*,
5127  void(*)(void *,int ,char const *,char const *,sqlite3_int64),
5128  void*
5129);
5130
5131/*
5132** CAPI3REF: Enable Or Disable Shared Pager Cache
5133**
5134** ^(This routine enables or disables the sharing of the database cache
5135** and schema data structures between [database connection | connections]
5136** to the same database. Sharing is enabled if the argument is true
5137** and disabled if the argument is false.)^
5138**
5139** ^Cache sharing is enabled and disabled for an entire process.
5140** This is a change as of SQLite version 3.5.0. In prior versions of SQLite,
5141** sharing was enabled or disabled for each thread separately.
5142**
5143** ^(The cache sharing mode set by this interface effects all subsequent
5144** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
5145** Existing database connections continue use the sharing mode
5146** that was in effect at the time they were opened.)^
5147**
5148** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
5149** successfully.  An [error code] is returned otherwise.)^
5150**
5151** ^Shared cache is disabled by default. But this might change in
5152** future releases of SQLite.  Applications that care about shared
5153** cache setting should set it explicitly.
5154**
5155** This interface is threadsafe on processors where writing a
5156** 32-bit integer is atomic.
5157**
5158** See Also:  [SQLite Shared-Cache Mode]
5159*/
5160SQLITE_API int sqlite3_enable_shared_cache(int);
5161
5162/*
5163** CAPI3REF: Attempt To Free Heap Memory
5164**
5165** ^The sqlite3_release_memory() interface attempts to free N bytes
5166** of heap memory by deallocating non-essential memory allocations
5167** held by the database library.   Memory used to cache database
5168** pages to improve performance is an example of non-essential memory.
5169** ^sqlite3_release_memory() returns the number of bytes actually freed,
5170** which might be more or less than the amount requested.
5171** ^The sqlite3_release_memory() routine is a no-op returning zero
5172** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5173**
5174** See also: [sqlite3_db_release_memory()]
5175*/
5176SQLITE_API int sqlite3_release_memory(int);
5177
5178/*
5179** CAPI3REF: Free Memory Used By A Database Connection
5180**
5181** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
5182** memory as possible from database connection D. Unlike the
5183** [sqlite3_release_memory()] interface, this interface is in effect even
5184** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
5185** omitted.
5186**
5187** See also: [sqlite3_release_memory()]
5188*/
5189SQLITE_API int sqlite3_db_release_memory(sqlite3*);
5190
5191/*
5192** CAPI3REF: Impose A Limit On Heap Size
5193**
5194** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the
5195** soft limit on the amount of heap memory that may be allocated by SQLite.
5196** ^SQLite strives to keep heap memory utilization below the soft heap
5197** limit by reducing the number of pages held in the page cache
5198** as heap memory usages approaches the limit.
5199** ^The soft heap limit is "soft" because even though SQLite strives to stay
5200** below the limit, it will exceed the limit rather than generate
5201** an [SQLITE_NOMEM] error.  In other words, the soft heap limit
5202** is advisory only.
5203**
5204** ^The return value from sqlite3_soft_heap_limit64() is the size of
5205** the soft heap limit prior to the call, or negative in the case of an
5206** error.  ^If the argument N is negative
5207** then no change is made to the soft heap limit.  Hence, the current
5208** size of the soft heap limit can be determined by invoking
5209** sqlite3_soft_heap_limit64() with a negative argument.
5210**
5211** ^If the argument N is zero then the soft heap limit is disabled.
5212**
5213** ^(The soft heap limit is not enforced in the current implementation
5214** if one or more of following conditions are true:
5215**
5216** <ul>
5217** <li> The soft heap limit is set to zero.
5218** <li> Memory accounting is disabled using a combination of the
5219**      [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
5220**      the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
5221** <li> An alternative page cache implementation is specified using
5222**      [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
5223** <li> The page cache allocates from its own memory pool supplied
5224**      by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
5225**      from the heap.
5226** </ul>)^
5227**
5228** Beginning with SQLite version 3.7.3, the soft heap limit is enforced
5229** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
5230** compile-time option is invoked.  With [SQLITE_ENABLE_MEMORY_MANAGEMENT],
5231** the soft heap limit is enforced on every memory allocation.  Without
5232** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced
5233** when memory is allocated by the page cache.  Testing suggests that because
5234** the page cache is the predominate memory user in SQLite, most
5235** applications will achieve adequate soft heap limit enforcement without
5236** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5237**
5238** The circumstances under which SQLite will enforce the soft heap limit may
5239** changes in future releases of SQLite.
5240*/
5241SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
5242
5243/*
5244** CAPI3REF: Deprecated Soft Heap Limit Interface
5245** DEPRECATED
5246**
5247** This is a deprecated version of the [sqlite3_soft_heap_limit64()]
5248** interface.  This routine is provided for historical compatibility
5249** only.  All new applications should use the
5250** [sqlite3_soft_heap_limit64()] interface rather than this one.
5251*/
5252SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
5253
5254
5255/*
5256** CAPI3REF: Extract Metadata About A Column Of A Table
5257**
5258** ^This routine returns metadata about a specific column of a specific
5259** database table accessible using the [database connection] handle
5260** passed as the first function argument.
5261**
5262** ^The column is identified by the second, third and fourth parameters to
5263** this function. ^The second parameter is either the name of the database
5264** (i.e. "main", "temp", or an attached database) containing the specified
5265** table or NULL. ^If it is NULL, then all attached databases are searched
5266** for the table using the same algorithm used by the database engine to
5267** resolve unqualified table references.
5268**
5269** ^The third and fourth parameters to this function are the table and column
5270** name of the desired column, respectively. Neither of these parameters
5271** may be NULL.
5272**
5273** ^Metadata is returned by writing to the memory locations passed as the 5th
5274** and subsequent parameters to this function. ^Any of these arguments may be
5275** NULL, in which case the corresponding element of metadata is omitted.
5276**
5277** ^(<blockquote>
5278** <table border="1">
5279** <tr><th> Parameter <th> Output<br>Type <th>  Description
5280**
5281** <tr><td> 5th <td> const char* <td> Data type
5282** <tr><td> 6th <td> const char* <td> Name of default collation sequence
5283** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
5284** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
5285** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
5286** </table>
5287** </blockquote>)^
5288**
5289** ^The memory pointed to by the character pointers returned for the
5290** declaration type and collation sequence is valid only until the next
5291** call to any SQLite API function.
5292**
5293** ^If the specified table is actually a view, an [error code] is returned.
5294**
5295** ^If the specified column is "rowid", "oid" or "_rowid_" and an
5296** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
5297** parameters are set for the explicitly declared column. ^(If there is no
5298** explicitly declared [INTEGER PRIMARY KEY] column, then the output
5299** parameters are set as follows:
5300**
5301** <pre>
5302**     data type: "INTEGER"
5303**     collation sequence: "BINARY"
5304**     not null: 0
5305**     primary key: 1
5306**     auto increment: 0
5307** </pre>)^
5308**
5309** ^(This function may load one or more schemas from database files. If an
5310** error occurs during this process, or if the requested table or column
5311** cannot be found, an [error code] is returned and an error message left
5312** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
5313**
5314** ^This API is only available if the library was compiled with the
5315** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
5316*/
5317SQLITE_API int sqlite3_table_column_metadata(
5318  sqlite3 *db,                /* Connection handle */
5319  const char *zDbName,        /* Database name or NULL */
5320  const char *zTableName,     /* Table name */
5321  const char *zColumnName,    /* Column name */
5322  char const **pzDataType,    /* OUTPUT: Declared data type */
5323  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
5324  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
5325  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
5326  int *pAutoinc               /* OUTPUT: True if column is auto-increment */
5327);
5328
5329/*
5330** CAPI3REF: Load An Extension
5331**
5332** ^This interface loads an SQLite extension library from the named file.
5333**
5334** ^The sqlite3_load_extension() interface attempts to load an
5335** [SQLite extension] library contained in the file zFile.  If
5336** the file cannot be loaded directly, attempts are made to load
5337** with various operating-system specific extensions added.
5338** So for example, if "samplelib" cannot be loaded, then names like
5339** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might
5340** be tried also.
5341**
5342** ^The entry point is zProc.
5343** ^(zProc may be 0, in which case SQLite will try to come up with an
5344** entry point name on its own.  It first tries "sqlite3_extension_init".
5345** If that does not work, it constructs a name "sqlite3_X_init" where the
5346** X is consists of the lower-case equivalent of all ASCII alphabetic
5347** characters in the filename from the last "/" to the first following
5348** "." and omitting any initial "lib".)^
5349** ^The sqlite3_load_extension() interface returns
5350** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
5351** ^If an error occurs and pzErrMsg is not 0, then the
5352** [sqlite3_load_extension()] interface shall attempt to
5353** fill *pzErrMsg with error message text stored in memory
5354** obtained from [sqlite3_malloc()]. The calling function
5355** should free this memory by calling [sqlite3_free()].
5356**
5357** ^Extension loading must be enabled using
5358** [sqlite3_enable_load_extension()] prior to calling this API,
5359** otherwise an error will be returned.
5360**
5361** See also the [load_extension() SQL function].
5362*/
5363SQLITE_API int sqlite3_load_extension(
5364  sqlite3 *db,          /* Load the extension into this database connection */
5365  const char *zFile,    /* Name of the shared library containing extension */
5366  const char *zProc,    /* Entry point.  Derived from zFile if 0 */
5367  char **pzErrMsg       /* Put error message here if not 0 */
5368);
5369
5370/*
5371** CAPI3REF: Enable Or Disable Extension Loading
5372**
5373** ^So as not to open security holes in older applications that are
5374** unprepared to deal with [extension loading], and as a means of disabling
5375** [extension loading] while evaluating user-entered SQL, the following API
5376** is provided to turn the [sqlite3_load_extension()] mechanism on and off.
5377**
5378** ^Extension loading is off by default.
5379** ^Call the sqlite3_enable_load_extension() routine with onoff==1
5380** to turn extension loading on and call it with onoff==0 to turn
5381** it back off again.
5382*/
5383SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
5384
5385/*
5386** CAPI3REF: Automatically Load Statically Linked Extensions
5387**
5388** ^This interface causes the xEntryPoint() function to be invoked for
5389** each new [database connection] that is created.  The idea here is that
5390** xEntryPoint() is the entry point for a statically linked [SQLite extension]
5391** that is to be automatically loaded into all new database connections.
5392**
5393** ^(Even though the function prototype shows that xEntryPoint() takes
5394** no arguments and returns void, SQLite invokes xEntryPoint() with three
5395** arguments and expects and integer result as if the signature of the
5396** entry point where as follows:
5397**
5398** <blockquote><pre>
5399** &nbsp;  int xEntryPoint(
5400** &nbsp;    sqlite3 *db,
5401** &nbsp;    const char **pzErrMsg,
5402** &nbsp;    const struct sqlite3_api_routines *pThunk
5403** &nbsp;  );
5404** </pre></blockquote>)^
5405**
5406** If the xEntryPoint routine encounters an error, it should make *pzErrMsg
5407** point to an appropriate error message (obtained from [sqlite3_mprintf()])
5408** and return an appropriate [error code].  ^SQLite ensures that *pzErrMsg
5409** is NULL before calling the xEntryPoint().  ^SQLite will invoke
5410** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns.  ^If any
5411** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()],
5412** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail.
5413**
5414** ^Calling sqlite3_auto_extension(X) with an entry point X that is already
5415** on the list of automatic extensions is a harmless no-op. ^No entry point
5416** will be called more than once for each database connection that is opened.
5417**
5418** See also: [sqlite3_reset_auto_extension()]
5419** and [sqlite3_cancel_auto_extension()]
5420*/
5421SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
5422
5423/*
5424** CAPI3REF: Cancel Automatic Extension Loading
5425**
5426** ^The [sqlite3_cancel_auto_extension(X)] interface unregisters the
5427** initialization routine X that was registered using a prior call to
5428** [sqlite3_auto_extension(X)].  ^The [sqlite3_cancel_auto_extension(X)]
5429** routine returns 1 if initialization routine X was successfully
5430** unregistered and it returns 0 if X was not on the list of initialization
5431** routines.
5432*/
5433SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
5434
5435/*
5436** CAPI3REF: Reset Automatic Extension Loading
5437**
5438** ^This interface disables all automatic extensions previously
5439** registered using [sqlite3_auto_extension()].
5440*/
5441SQLITE_API void sqlite3_reset_auto_extension(void);
5442
5443/*
5444** The interface to the virtual-table mechanism is currently considered
5445** to be experimental.  The interface might change in incompatible ways.
5446** If this is a problem for you, do not use the interface at this time.
5447**
5448** When the virtual-table mechanism stabilizes, we will declare the
5449** interface fixed, support it indefinitely, and remove this comment.
5450*/
5451
5452/*
5453** Structures used by the virtual table interface
5454*/
5455typedef struct sqlite3_vtab sqlite3_vtab;
5456typedef struct sqlite3_index_info sqlite3_index_info;
5457typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
5458typedef struct sqlite3_module sqlite3_module;
5459
5460/*
5461** CAPI3REF: Virtual Table Object
5462** KEYWORDS: sqlite3_module {virtual table module}
5463**
5464** This structure, sometimes called a "virtual table module",
5465** defines the implementation of a [virtual tables].
5466** This structure consists mostly of methods for the module.
5467**
5468** ^A virtual table module is created by filling in a persistent
5469** instance of this structure and passing a pointer to that instance
5470** to [sqlite3_create_module()] or [sqlite3_create_module_v2()].
5471** ^The registration remains valid until it is replaced by a different
5472** module or until the [database connection] closes.  The content
5473** of this structure must not change while it is registered with
5474** any database connection.
5475*/
5476struct sqlite3_module {
5477  int iVersion;
5478  int (*xCreate)(sqlite3*, void *pAux,
5479               int argc, const char *const*argv,
5480               sqlite3_vtab **ppVTab, char**);
5481  int (*xConnect)(sqlite3*, void *pAux,
5482               int argc, const char *const*argv,
5483               sqlite3_vtab **ppVTab, char**);
5484  int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
5485  int (*xDisconnect)(sqlite3_vtab *pVTab);
5486  int (*xDestroy)(sqlite3_vtab *pVTab);
5487  int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
5488  int (*xClose)(sqlite3_vtab_cursor*);
5489  int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
5490                int argc, sqlite3_value **argv);
5491  int (*xNext)(sqlite3_vtab_cursor*);
5492  int (*xEof)(sqlite3_vtab_cursor*);
5493  int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
5494  int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
5495  int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
5496  int (*xBegin)(sqlite3_vtab *pVTab);
5497  int (*xSync)(sqlite3_vtab *pVTab);
5498  int (*xCommit)(sqlite3_vtab *pVTab);
5499  int (*xRollback)(sqlite3_vtab *pVTab);
5500  int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
5501                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
5502                       void **ppArg);
5503  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
5504  /* The methods above are in version 1 of the sqlite_module object. Those
5505  ** below are for version 2 and greater. */
5506  int (*xSavepoint)(sqlite3_vtab *pVTab, int);
5507  int (*xRelease)(sqlite3_vtab *pVTab, int);
5508  int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
5509};
5510
5511/*
5512** CAPI3REF: Virtual Table Indexing Information
5513** KEYWORDS: sqlite3_index_info
5514**
5515** The sqlite3_index_info structure and its substructures is used as part
5516** of the [virtual table] interface to
5517** pass information into and receive the reply from the [xBestIndex]
5518** method of a [virtual table module].  The fields under **Inputs** are the
5519** inputs to xBestIndex and are read-only.  xBestIndex inserts its
5520** results into the **Outputs** fields.
5521**
5522** ^(The aConstraint[] array records WHERE clause constraints of the form:
5523**
5524** <blockquote>column OP expr</blockquote>
5525**
5526** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^  ^(The particular operator is
5527** stored in aConstraint[].op using one of the
5528** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^
5529** ^(The index of the column is stored in
5530** aConstraint[].iColumn.)^  ^(aConstraint[].usable is TRUE if the
5531** expr on the right-hand side can be evaluated (and thus the constraint
5532** is usable) and false if it cannot.)^
5533**
5534** ^The optimizer automatically inverts terms of the form "expr OP column"
5535** and makes other simplifications to the WHERE clause in an attempt to
5536** get as many WHERE clause terms into the form shown above as possible.
5537** ^The aConstraint[] array only reports WHERE clause terms that are
5538** relevant to the particular virtual table being queried.
5539**
5540** ^Information about the ORDER BY clause is stored in aOrderBy[].
5541** ^Each term of aOrderBy records a column of the ORDER BY clause.
5542**
5543** The [xBestIndex] method must fill aConstraintUsage[] with information
5544** about what parameters to pass to xFilter.  ^If argvIndex>0 then
5545** the right-hand side of the corresponding aConstraint[] is evaluated
5546** and becomes the argvIndex-th entry in argv.  ^(If aConstraintUsage[].omit
5547** is true, then the constraint is assumed to be fully handled by the
5548** virtual table and is not checked again by SQLite.)^
5549**
5550** ^The idxNum and idxPtr values are recorded and passed into the
5551** [xFilter] method.
5552** ^[sqlite3_free()] is used to free idxPtr if and only if
5553** needToFreeIdxPtr is true.
5554**
5555** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
5556** the correct order to satisfy the ORDER BY clause so that no separate
5557** sorting step is required.
5558**
5559** ^The estimatedCost value is an estimate of the cost of a particular
5560** strategy. A cost of N indicates that the cost of the strategy is similar
5561** to a linear scan of an SQLite table with N rows. A cost of log(N)
5562** indicates that the expense of the operation is similar to that of a
5563** binary search on a unique indexed field of an SQLite table with N rows.
5564**
5565** ^The estimatedRows value is an estimate of the number of rows that
5566** will be returned by the strategy.
5567**
5568** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info
5569** structure for SQLite version 3.8.2. If a virtual table extension is
5570** used with an SQLite version earlier than 3.8.2, the results of attempting
5571** to read or write the estimatedRows field are undefined (but are likely
5572** to included crashing the application). The estimatedRows field should
5573** therefore only be used if [sqlite3_libversion_number()] returns a
5574** value greater than or equal to 3008002.
5575*/
5576struct sqlite3_index_info {
5577  /* Inputs */
5578  int nConstraint;           /* Number of entries in aConstraint */
5579  struct sqlite3_index_constraint {
5580     int iColumn;              /* Column on left-hand side of constraint */
5581     unsigned char op;         /* Constraint operator */
5582     unsigned char usable;     /* True if this constraint is usable */
5583     int iTermOffset;          /* Used internally - xBestIndex should ignore */
5584  } *aConstraint;            /* Table of WHERE clause constraints */
5585  int nOrderBy;              /* Number of terms in the ORDER BY clause */
5586  struct sqlite3_index_orderby {
5587     int iColumn;              /* Column number */
5588     unsigned char desc;       /* True for DESC.  False for ASC. */
5589  } *aOrderBy;               /* The ORDER BY clause */
5590  /* Outputs */
5591  struct sqlite3_index_constraint_usage {
5592    int argvIndex;           /* if >0, constraint is part of argv to xFilter */
5593    unsigned char omit;      /* Do not code a test for this constraint */
5594  } *aConstraintUsage;
5595  int idxNum;                /* Number used to identify the index */
5596  char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
5597  int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
5598  int orderByConsumed;       /* True if output is already ordered */
5599  double estimatedCost;           /* Estimated cost of using this index */
5600  /* Fields below are only available in SQLite 3.8.2 and later */
5601  sqlite3_int64 estimatedRows;    /* Estimated number of rows returned */
5602};
5603
5604/*
5605** CAPI3REF: Virtual Table Constraint Operator Codes
5606**
5607** These macros defined the allowed values for the
5608** [sqlite3_index_info].aConstraint[].op field.  Each value represents
5609** an operator that is part of a constraint term in the wHERE clause of
5610** a query that uses a [virtual table].
5611*/
5612#define SQLITE_INDEX_CONSTRAINT_EQ    2
5613#define SQLITE_INDEX_CONSTRAINT_GT    4
5614#define SQLITE_INDEX_CONSTRAINT_LE    8
5615#define SQLITE_INDEX_CONSTRAINT_LT    16
5616#define SQLITE_INDEX_CONSTRAINT_GE    32
5617#define SQLITE_INDEX_CONSTRAINT_MATCH 64
5618
5619/*
5620** CAPI3REF: Register A Virtual Table Implementation
5621**
5622** ^These routines are used to register a new [virtual table module] name.
5623** ^Module names must be registered before
5624** creating a new [virtual table] using the module and before using a
5625** preexisting [virtual table] for the module.
5626**
5627** ^The module name is registered on the [database connection] specified
5628** by the first parameter.  ^The name of the module is given by the
5629** second parameter.  ^The third parameter is a pointer to
5630** the implementation of the [virtual table module].   ^The fourth
5631** parameter is an arbitrary client data pointer that is passed through
5632** into the [xCreate] and [xConnect] methods of the virtual table module
5633** when a new virtual table is be being created or reinitialized.
5634**
5635** ^The sqlite3_create_module_v2() interface has a fifth parameter which
5636** is a pointer to a destructor for the pClientData.  ^SQLite will
5637** invoke the destructor function (if it is not NULL) when SQLite
5638** no longer needs the pClientData pointer.  ^The destructor will also
5639** be invoked if the call to sqlite3_create_module_v2() fails.
5640** ^The sqlite3_create_module()
5641** interface is equivalent to sqlite3_create_module_v2() with a NULL
5642** destructor.
5643*/
5644SQLITE_API int sqlite3_create_module(
5645  sqlite3 *db,               /* SQLite connection to register module with */
5646  const char *zName,         /* Name of the module */
5647  const sqlite3_module *p,   /* Methods for the module */
5648  void *pClientData          /* Client data for xCreate/xConnect */
5649);
5650SQLITE_API int sqlite3_create_module_v2(
5651  sqlite3 *db,               /* SQLite connection to register module with */
5652  const char *zName,         /* Name of the module */
5653  const sqlite3_module *p,   /* Methods for the module */
5654  void *pClientData,         /* Client data for xCreate/xConnect */
5655  void(*xDestroy)(void*)     /* Module destructor function */
5656);
5657
5658/*
5659** CAPI3REF: Virtual Table Instance Object
5660** KEYWORDS: sqlite3_vtab
5661**
5662** Every [virtual table module] implementation uses a subclass
5663** of this object to describe a particular instance
5664** of the [virtual table].  Each subclass will
5665** be tailored to the specific needs of the module implementation.
5666** The purpose of this superclass is to define certain fields that are
5667** common to all module implementations.
5668**
5669** ^Virtual tables methods can set an error message by assigning a
5670** string obtained from [sqlite3_mprintf()] to zErrMsg.  The method should
5671** take care that any prior string is freed by a call to [sqlite3_free()]
5672** prior to assigning a new string to zErrMsg.  ^After the error message
5673** is delivered up to the client application, the string will be automatically
5674** freed by sqlite3_free() and the zErrMsg field will be zeroed.
5675*/
5676struct sqlite3_vtab {
5677  const sqlite3_module *pModule;  /* The module for this virtual table */
5678  int nRef;                       /* NO LONGER USED */
5679  char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
5680  /* Virtual table implementations will typically add additional fields */
5681};
5682
5683/*
5684** CAPI3REF: Virtual Table Cursor Object
5685** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor}
5686**
5687** Every [virtual table module] implementation uses a subclass of the
5688** following structure to describe cursors that point into the
5689** [virtual table] and are used
5690** to loop through the virtual table.  Cursors are created using the
5691** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed
5692** by the [sqlite3_module.xClose | xClose] method.  Cursors are used
5693** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods
5694** of the module.  Each module implementation will define
5695** the content of a cursor structure to suit its own needs.
5696**
5697** This superclass exists in order to define fields of the cursor that
5698** are common to all implementations.
5699*/
5700struct sqlite3_vtab_cursor {
5701  sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
5702  /* Virtual table implementations will typically add additional fields */
5703};
5704
5705/*
5706** CAPI3REF: Declare The Schema Of A Virtual Table
5707**
5708** ^The [xCreate] and [xConnect] methods of a
5709** [virtual table module] call this interface
5710** to declare the format (the names and datatypes of the columns) of
5711** the virtual tables they implement.
5712*/
5713SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
5714
5715/*
5716** CAPI3REF: Overload A Function For A Virtual Table
5717**
5718** ^(Virtual tables can provide alternative implementations of functions
5719** using the [xFindFunction] method of the [virtual table module].
5720** But global versions of those functions
5721** must exist in order to be overloaded.)^
5722**
5723** ^(This API makes sure a global version of a function with a particular
5724** name and number of parameters exists.  If no such function exists
5725** before this API is called, a new function is created.)^  ^The implementation
5726** of the new function always causes an exception to be thrown.  So
5727** the new function is not good for anything by itself.  Its only
5728** purpose is to be a placeholder function that can be overloaded
5729** by a [virtual table].
5730*/
5731SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
5732
5733/*
5734** The interface to the virtual-table mechanism defined above (back up
5735** to a comment remarkably similar to this one) is currently considered
5736** to be experimental.  The interface might change in incompatible ways.
5737** If this is a problem for you, do not use the interface at this time.
5738**
5739** When the virtual-table mechanism stabilizes, we will declare the
5740** interface fixed, support it indefinitely, and remove this comment.
5741*/
5742
5743/*
5744** CAPI3REF: A Handle To An Open BLOB
5745** KEYWORDS: {BLOB handle} {BLOB handles}
5746**
5747** An instance of this object represents an open BLOB on which
5748** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
5749** ^Objects of this type are created by [sqlite3_blob_open()]
5750** and destroyed by [sqlite3_blob_close()].
5751** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
5752** can be used to read or write small subsections of the BLOB.
5753** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
5754*/
5755typedef struct sqlite3_blob sqlite3_blob;
5756
5757/*
5758** CAPI3REF: Open A BLOB For Incremental I/O
5759**
5760** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
5761** in row iRow, column zColumn, table zTable in database zDb;
5762** in other words, the same BLOB that would be selected by:
5763**
5764** <pre>
5765**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
5766** </pre>)^
5767**
5768** ^If the flags parameter is non-zero, then the BLOB is opened for read
5769** and write access. ^If it is zero, the BLOB is opened for read access.
5770** ^It is not possible to open a column that is part of an index or primary
5771** key for writing. ^If [foreign key constraints] are enabled, it is
5772** not possible to open a column that is part of a [child key] for writing.
5773**
5774** ^Note that the database name is not the filename that contains
5775** the database but rather the symbolic name of the database that
5776** appears after the AS keyword when the database is connected using [ATTACH].
5777** ^For the main database file, the database name is "main".
5778** ^For TEMP tables, the database name is "temp".
5779**
5780** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
5781** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set
5782** to be a null pointer.)^
5783** ^This function sets the [database connection] error code and message
5784** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related
5785** functions. ^Note that the *ppBlob variable is always initialized in a
5786** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob
5787** regardless of the success or failure of this routine.
5788**
5789** ^(If the row that a BLOB handle points to is modified by an
5790** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
5791** then the BLOB handle is marked as "expired".
5792** This is true if any column of the row is changed, even a column
5793** other than the one the BLOB handle is open on.)^
5794** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for
5795** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
5796** ^(Changes written into a BLOB prior to the BLOB expiring are not
5797** rolled back by the expiration of the BLOB.  Such changes will eventually
5798** commit if the transaction continues to completion.)^
5799**
5800** ^Use the [sqlite3_blob_bytes()] interface to determine the size of
5801** the opened blob.  ^The size of a blob may not be changed by this
5802** interface.  Use the [UPDATE] SQL command to change the size of a
5803** blob.
5804**
5805** ^The [sqlite3_blob_open()] interface will fail for a [WITHOUT ROWID]
5806** table.  Incremental BLOB I/O is not possible on [WITHOUT ROWID] tables.
5807**
5808** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
5809** and the built-in [zeroblob] SQL function can be used, if desired,
5810** to create an empty, zero-filled blob in which to read or write using
5811** this interface.
5812**
5813** To avoid a resource leak, every open [BLOB handle] should eventually
5814** be released by a call to [sqlite3_blob_close()].
5815*/
5816SQLITE_API int sqlite3_blob_open(
5817  sqlite3*,
5818  const char *zDb,
5819  const char *zTable,
5820  const char *zColumn,
5821  sqlite3_int64 iRow,
5822  int flags,
5823  sqlite3_blob **ppBlob
5824);
5825
5826/*
5827** CAPI3REF: Move a BLOB Handle to a New Row
5828**
5829** ^This function is used to move an existing blob handle so that it points
5830** to a different row of the same database table. ^The new row is identified
5831** by the rowid value passed as the second argument. Only the row can be
5832** changed. ^The database, table and column on which the blob handle is open
5833** remain the same. Moving an existing blob handle to a new row can be
5834** faster than closing the existing handle and opening a new one.
5835**
5836** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
5837** it must exist and there must be either a blob or text value stored in
5838** the nominated column.)^ ^If the new row is not present in the table, or if
5839** it does not contain a blob or text value, or if another error occurs, an
5840** SQLite error code is returned and the blob handle is considered aborted.
5841** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or
5842** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
5843** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
5844** always returns zero.
5845**
5846** ^This function sets the database handle error code and message.
5847*/
5848SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
5849
5850/*
5851** CAPI3REF: Close A BLOB Handle
5852**
5853** ^Closes an open [BLOB handle].
5854**
5855** ^Closing a BLOB shall cause the current transaction to commit
5856** if there are no other BLOBs, no pending prepared statements, and the
5857** database connection is in [autocommit mode].
5858** ^If any writes were made to the BLOB, they might be held in cache
5859** until the close operation if they will fit.
5860**
5861** ^(Closing the BLOB often forces the changes
5862** out to disk and so if any I/O errors occur, they will likely occur
5863** at the time when the BLOB is closed.  Any errors that occur during
5864** closing are reported as a non-zero return value.)^
5865**
5866** ^(The BLOB is closed unconditionally.  Even if this routine returns
5867** an error code, the BLOB is still closed.)^
5868**
5869** ^Calling this routine with a null pointer (such as would be returned
5870** by a failed call to [sqlite3_blob_open()]) is a harmless no-op.
5871*/
5872SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
5873
5874/*
5875** CAPI3REF: Return The Size Of An Open BLOB
5876**
5877** ^Returns the size in bytes of the BLOB accessible via the
5878** successfully opened [BLOB handle] in its only argument.  ^The
5879** incremental blob I/O routines can only read or overwriting existing
5880** blob content; they cannot change the size of a blob.
5881**
5882** This routine only works on a [BLOB handle] which has been created
5883** by a prior successful call to [sqlite3_blob_open()] and which has not
5884** been closed by [sqlite3_blob_close()].  Passing any other pointer in
5885** to this routine results in undefined and probably undesirable behavior.
5886*/
5887SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
5888
5889/*
5890** CAPI3REF: Read Data From A BLOB Incrementally
5891**
5892** ^(This function is used to read data from an open [BLOB handle] into a
5893** caller-supplied buffer. N bytes of data are copied into buffer Z
5894** from the open BLOB, starting at offset iOffset.)^
5895**
5896** ^If offset iOffset is less than N bytes from the end of the BLOB,
5897** [SQLITE_ERROR] is returned and no data is read.  ^If N or iOffset is
5898** less than zero, [SQLITE_ERROR] is returned and no data is read.
5899** ^The size of the blob (and hence the maximum value of N+iOffset)
5900** can be determined using the [sqlite3_blob_bytes()] interface.
5901**
5902** ^An attempt to read from an expired [BLOB handle] fails with an
5903** error code of [SQLITE_ABORT].
5904**
5905** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
5906** Otherwise, an [error code] or an [extended error code] is returned.)^
5907**
5908** This routine only works on a [BLOB handle] which has been created
5909** by a prior successful call to [sqlite3_blob_open()] and which has not
5910** been closed by [sqlite3_blob_close()].  Passing any other pointer in
5911** to this routine results in undefined and probably undesirable behavior.
5912**
5913** See also: [sqlite3_blob_write()].
5914*/
5915SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5916
5917/*
5918** CAPI3REF: Write Data Into A BLOB Incrementally
5919**
5920** ^This function is used to write data into an open [BLOB handle] from a
5921** caller-supplied buffer. ^N bytes of data are copied from the buffer Z
5922** into the open BLOB, starting at offset iOffset.
5923**
5924** ^If the [BLOB handle] passed as the first argument was not opened for
5925** writing (the flags parameter to [sqlite3_blob_open()] was zero),
5926** this function returns [SQLITE_READONLY].
5927**
5928** ^This function may only modify the contents of the BLOB; it is
5929** not possible to increase the size of a BLOB using this API.
5930** ^If offset iOffset is less than N bytes from the end of the BLOB,
5931** [SQLITE_ERROR] is returned and no data is written.  ^If N is
5932** less than zero [SQLITE_ERROR] is returned and no data is written.
5933** The size of the BLOB (and hence the maximum value of N+iOffset)
5934** can be determined using the [sqlite3_blob_bytes()] interface.
5935**
5936** ^An attempt to write to an expired [BLOB handle] fails with an
5937** error code of [SQLITE_ABORT].  ^Writes to the BLOB that occurred
5938** before the [BLOB handle] expired are not rolled back by the
5939** expiration of the handle, though of course those changes might
5940** have been overwritten by the statement that expired the BLOB handle
5941** or by other independent statements.
5942**
5943** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
5944** Otherwise, an  [error code] or an [extended error code] is returned.)^
5945**
5946** This routine only works on a [BLOB handle] which has been created
5947** by a prior successful call to [sqlite3_blob_open()] and which has not
5948** been closed by [sqlite3_blob_close()].  Passing any other pointer in
5949** to this routine results in undefined and probably undesirable behavior.
5950**
5951** See also: [sqlite3_blob_read()].
5952*/
5953SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
5954
5955/*
5956** CAPI3REF: Virtual File System Objects
5957**
5958** A virtual filesystem (VFS) is an [sqlite3_vfs] object
5959** that SQLite uses to interact
5960** with the underlying operating system.  Most SQLite builds come with a
5961** single default VFS that is appropriate for the host computer.
5962** New VFSes can be registered and existing VFSes can be unregistered.
5963** The following interfaces are provided.
5964**
5965** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
5966** ^Names are case sensitive.
5967** ^Names are zero-terminated UTF-8 strings.
5968** ^If there is no match, a NULL pointer is returned.
5969** ^If zVfsName is NULL then the default VFS is returned.
5970**
5971** ^New VFSes are registered with sqlite3_vfs_register().
5972** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
5973** ^The same VFS can be registered multiple times without injury.
5974** ^To make an existing VFS into the default VFS, register it again
5975** with the makeDflt flag set.  If two different VFSes with the
5976** same name are registered, the behavior is undefined.  If a
5977** VFS is registered with a name that is NULL or an empty string,
5978** then the behavior is undefined.
5979**
5980** ^Unregister a VFS with the sqlite3_vfs_unregister() interface.
5981** ^(If the default VFS is unregistered, another VFS is chosen as
5982** the default.  The choice for the new VFS is arbitrary.)^
5983*/
5984SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
5985SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
5986SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
5987
5988/*
5989** CAPI3REF: Mutexes
5990**
5991** The SQLite core uses these routines for thread
5992** synchronization. Though they are intended for internal
5993** use by SQLite, code that links against SQLite is
5994** permitted to use any of these routines.
5995**
5996** The SQLite source code contains multiple implementations
5997** of these mutex routines.  An appropriate implementation
5998** is selected automatically at compile-time.  ^(The following
5999** implementations are available in the SQLite core:
6000**
6001** <ul>
6002** <li>   SQLITE_MUTEX_PTHREADS
6003** <li>   SQLITE_MUTEX_W32
6004** <li>   SQLITE_MUTEX_NOOP
6005** </ul>)^
6006**
6007** ^The SQLITE_MUTEX_NOOP implementation is a set of routines
6008** that does no real locking and is appropriate for use in
6009** a single-threaded application.  ^The SQLITE_MUTEX_PTHREADS and
6010** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix
6011** and Windows.
6012**
6013** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
6014** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
6015** implementation is included with the library. In this case the
6016** application must supply a custom mutex implementation using the
6017** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
6018** before calling sqlite3_initialize() or any other public sqlite3_
6019** function that calls sqlite3_initialize().)^
6020**
6021** ^The sqlite3_mutex_alloc() routine allocates a new
6022** mutex and returns a pointer to it. ^If it returns NULL
6023** that means that a mutex could not be allocated.  ^SQLite
6024** will unwind its stack and return an error.  ^(The argument
6025** to sqlite3_mutex_alloc() is one of these integer constants:
6026**
6027** <ul>
6028** <li>  SQLITE_MUTEX_FAST
6029** <li>  SQLITE_MUTEX_RECURSIVE
6030** <li>  SQLITE_MUTEX_STATIC_MASTER
6031** <li>  SQLITE_MUTEX_STATIC_MEM
6032** <li>  SQLITE_MUTEX_STATIC_OPEN
6033** <li>  SQLITE_MUTEX_STATIC_PRNG
6034** <li>  SQLITE_MUTEX_STATIC_LRU
6035** <li>  SQLITE_MUTEX_STATIC_PMEM
6036** <li>  SQLITE_MUTEX_STATIC_APP1
6037** <li>  SQLITE_MUTEX_STATIC_APP2
6038** </ul>)^
6039**
6040** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
6041** cause sqlite3_mutex_alloc() to create
6042** a new mutex.  ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
6043** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
6044** The mutex implementation does not need to make a distinction
6045** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
6046** not want to.  ^SQLite will only request a recursive mutex in
6047** cases where it really needs one.  ^If a faster non-recursive mutex
6048** implementation is available on the host platform, the mutex subsystem
6049** might return such a mutex in response to SQLITE_MUTEX_FAST.
6050**
6051** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
6052** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
6053** a pointer to a static preexisting mutex.  ^Six static mutexes are
6054** used by the current version of SQLite.  Future versions of SQLite
6055** may add additional static mutexes.  Static mutexes are for internal
6056** use by SQLite only.  Applications that use SQLite mutexes should
6057** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
6058** SQLITE_MUTEX_RECURSIVE.
6059**
6060** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
6061** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
6062** returns a different mutex on every call.  ^But for the static
6063** mutex types, the same mutex is returned on every call that has
6064** the same type number.
6065**
6066** ^The sqlite3_mutex_free() routine deallocates a previously
6067** allocated dynamic mutex.  ^SQLite is careful to deallocate every
6068** dynamic mutex that it allocates.  The dynamic mutexes must not be in
6069** use when they are deallocated.  Attempting to deallocate a static
6070** mutex results in undefined behavior.  ^SQLite never deallocates
6071** a static mutex.
6072**
6073** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
6074** to enter a mutex.  ^If another thread is already within the mutex,
6075** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
6076** SQLITE_BUSY.  ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
6077** upon successful entry.  ^(Mutexes created using
6078** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
6079** In such cases the,
6080** mutex must be exited an equal number of times before another thread
6081** can enter.)^  ^(If the same thread tries to enter any other
6082** kind of mutex more than once, the behavior is undefined.
6083** SQLite will never exhibit
6084** such behavior in its own use of mutexes.)^
6085**
6086** ^(Some systems (for example, Windows 95) do not support the operation
6087** implemented by sqlite3_mutex_try().  On those systems, sqlite3_mutex_try()
6088** will always return SQLITE_BUSY.  The SQLite core only ever uses
6089** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^
6090**
6091** ^The sqlite3_mutex_leave() routine exits a mutex that was
6092** previously entered by the same thread.   ^(The behavior
6093** is undefined if the mutex is not currently entered by the
6094** calling thread or is not currently allocated.  SQLite will
6095** never do either.)^
6096**
6097** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
6098** sqlite3_mutex_leave() is a NULL pointer, then all three routines
6099** behave as no-ops.
6100**
6101** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
6102*/
6103SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
6104SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
6105SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
6106SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
6107SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
6108
6109/*
6110** CAPI3REF: Mutex Methods Object
6111**
6112** An instance of this structure defines the low-level routines
6113** used to allocate and use mutexes.
6114**
6115** Usually, the default mutex implementations provided by SQLite are
6116** sufficient, however the user has the option of substituting a custom
6117** implementation for specialized deployments or systems for which SQLite
6118** does not provide a suitable implementation. In this case, the user
6119** creates and populates an instance of this structure to pass
6120** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
6121** Additionally, an instance of this structure can be used as an
6122** output variable when querying the system for the current mutex
6123** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
6124**
6125** ^The xMutexInit method defined by this structure is invoked as
6126** part of system initialization by the sqlite3_initialize() function.
6127** ^The xMutexInit routine is called by SQLite exactly once for each
6128** effective call to [sqlite3_initialize()].
6129**
6130** ^The xMutexEnd method defined by this structure is invoked as
6131** part of system shutdown by the sqlite3_shutdown() function. The
6132** implementation of this method is expected to release all outstanding
6133** resources obtained by the mutex methods implementation, especially
6134** those obtained by the xMutexInit method.  ^The xMutexEnd()
6135** interface is invoked exactly once for each call to [sqlite3_shutdown()].
6136**
6137** ^(The remaining seven methods defined by this structure (xMutexAlloc,
6138** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
6139** xMutexNotheld) implement the following interfaces (respectively):
6140**
6141** <ul>
6142**   <li>  [sqlite3_mutex_alloc()] </li>
6143**   <li>  [sqlite3_mutex_free()] </li>
6144**   <li>  [sqlite3_mutex_enter()] </li>
6145**   <li>  [sqlite3_mutex_try()] </li>
6146**   <li>  [sqlite3_mutex_leave()] </li>
6147**   <li>  [sqlite3_mutex_held()] </li>
6148**   <li>  [sqlite3_mutex_notheld()] </li>
6149** </ul>)^
6150**
6151** The only difference is that the public sqlite3_XXX functions enumerated
6152** above silently ignore any invocations that pass a NULL pointer instead
6153** of a valid mutex handle. The implementations of the methods defined
6154** by this structure are not required to handle this case, the results
6155** of passing a NULL pointer instead of a valid mutex handle are undefined
6156** (i.e. it is acceptable to provide an implementation that segfaults if
6157** it is passed a NULL pointer).
6158**
6159** The xMutexInit() method must be threadsafe.  ^It must be harmless to
6160** invoke xMutexInit() multiple times within the same process and without
6161** intervening calls to xMutexEnd().  Second and subsequent calls to
6162** xMutexInit() must be no-ops.
6163**
6164** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
6165** and its associates).  ^Similarly, xMutexAlloc() must not use SQLite memory
6166** allocation for a static mutex.  ^However xMutexAlloc() may use SQLite
6167** memory allocation for a fast or recursive mutex.
6168**
6169** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
6170** called, but only if the prior call to xMutexInit returned SQLITE_OK.
6171** If xMutexInit fails in any way, it is expected to clean up after itself
6172** prior to returning.
6173*/
6174typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
6175struct sqlite3_mutex_methods {
6176  int (*xMutexInit)(void);
6177  int (*xMutexEnd)(void);
6178  sqlite3_mutex *(*xMutexAlloc)(int);
6179  void (*xMutexFree)(sqlite3_mutex *);
6180  void (*xMutexEnter)(sqlite3_mutex *);
6181  int (*xMutexTry)(sqlite3_mutex *);
6182  void (*xMutexLeave)(sqlite3_mutex *);
6183  int (*xMutexHeld)(sqlite3_mutex *);
6184  int (*xMutexNotheld)(sqlite3_mutex *);
6185};
6186
6187/*
6188** CAPI3REF: Mutex Verification Routines
6189**
6190** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
6191** are intended for use inside assert() statements.  ^The SQLite core
6192** never uses these routines except inside an assert() and applications
6193** are advised to follow the lead of the core.  ^The SQLite core only
6194** provides implementations for these routines when it is compiled
6195** with the SQLITE_DEBUG flag.  ^External mutex implementations
6196** are only required to provide these routines if SQLITE_DEBUG is
6197** defined and if NDEBUG is not defined.
6198**
6199** ^These routines should return true if the mutex in their argument
6200** is held or not held, respectively, by the calling thread.
6201**
6202** ^The implementation is not required to provide versions of these
6203** routines that actually work. If the implementation does not provide working
6204** versions of these routines, it should at least provide stubs that always
6205** return true so that one does not get spurious assertion failures.
6206**
6207** ^If the argument to sqlite3_mutex_held() is a NULL pointer then
6208** the routine should return 1.   This seems counter-intuitive since
6209** clearly the mutex cannot be held if it does not exist.  But
6210** the reason the mutex does not exist is because the build is not
6211** using mutexes.  And we do not want the assert() containing the
6212** call to sqlite3_mutex_held() to fail, so a non-zero return is
6213** the appropriate thing to do.  ^The sqlite3_mutex_notheld()
6214** interface should also return 1 when given a NULL pointer.
6215*/
6216#ifndef NDEBUG
6217SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
6218SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
6219#endif
6220
6221/*
6222** CAPI3REF: Mutex Types
6223**
6224** The [sqlite3_mutex_alloc()] interface takes a single argument
6225** which is one of these integer constants.
6226**
6227** The set of static mutexes may change from one SQLite release to the
6228** next.  Applications that override the built-in mutex logic must be
6229** prepared to accommodate additional static mutexes.
6230*/
6231#define SQLITE_MUTEX_FAST             0
6232#define SQLITE_MUTEX_RECURSIVE        1
6233#define SQLITE_MUTEX_STATIC_MASTER    2
6234#define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
6235#define SQLITE_MUTEX_STATIC_MEM2      4  /* NOT USED */
6236#define SQLITE_MUTEX_STATIC_OPEN      4  /* sqlite3BtreeOpen() */
6237#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
6238#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
6239#define SQLITE_MUTEX_STATIC_LRU2      7  /* NOT USED */
6240#define SQLITE_MUTEX_STATIC_PMEM      7  /* sqlite3PageMalloc() */
6241#define SQLITE_MUTEX_STATIC_APP1      8  /* For use by application */
6242#define SQLITE_MUTEX_STATIC_APP2      9  /* For use by application */
6243#define SQLITE_MUTEX_STATIC_APP3     10  /* For use by application */
6244
6245/*
6246** CAPI3REF: Retrieve the mutex for a database connection
6247**
6248** ^This interface returns a pointer the [sqlite3_mutex] object that
6249** serializes access to the [database connection] given in the argument
6250** when the [threading mode] is Serialized.
6251** ^If the [threading mode] is Single-thread or Multi-thread then this
6252** routine returns a NULL pointer.
6253*/
6254SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
6255
6256/*
6257** CAPI3REF: Low-Level Control Of Database Files
6258**
6259** ^The [sqlite3_file_control()] interface makes a direct call to the
6260** xFileControl method for the [sqlite3_io_methods] object associated
6261** with a particular database identified by the second argument. ^The
6262** name of the database is "main" for the main database or "temp" for the
6263** TEMP database, or the name that appears after the AS keyword for
6264** databases that are added using the [ATTACH] SQL command.
6265** ^A NULL pointer can be used in place of "main" to refer to the
6266** main database file.
6267** ^The third and fourth parameters to this routine
6268** are passed directly through to the second and third parameters of
6269** the xFileControl method.  ^The return value of the xFileControl
6270** method becomes the return value of this routine.
6271**
6272** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes
6273** a pointer to the underlying [sqlite3_file] object to be written into
6274** the space pointed to by the 4th parameter.  ^The SQLITE_FCNTL_FILE_POINTER
6275** case is a short-circuit path which does not actually invoke the
6276** underlying sqlite3_io_methods.xFileControl method.
6277**
6278** ^If the second parameter (zDbName) does not match the name of any
6279** open database file, then SQLITE_ERROR is returned.  ^This error
6280** code is not remembered and will not be recalled by [sqlite3_errcode()]
6281** or [sqlite3_errmsg()].  The underlying xFileControl method might
6282** also return SQLITE_ERROR.  There is no way to distinguish between
6283** an incorrect zDbName and an SQLITE_ERROR return from the underlying
6284** xFileControl method.
6285**
6286** See also: [SQLITE_FCNTL_LOCKSTATE]
6287*/
6288SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
6289
6290/*
6291** CAPI3REF: Testing Interface
6292**
6293** ^The sqlite3_test_control() interface is used to read out internal
6294** state of SQLite and to inject faults into SQLite for testing
6295** purposes.  ^The first parameter is an operation code that determines
6296** the number, meaning, and operation of all subsequent parameters.
6297**
6298** This interface is not for use by applications.  It exists solely
6299** for verifying the correct operation of the SQLite library.  Depending
6300** on how the SQLite library is compiled, this interface might not exist.
6301**
6302** The details of the operation codes, their meanings, the parameters
6303** they take, and what they do are all subject to change without notice.
6304** Unlike most of the SQLite API, this function is not guaranteed to
6305** operate consistently from one release to the next.
6306*/
6307SQLITE_API int sqlite3_test_control(int op, ...);
6308
6309/*
6310** CAPI3REF: Testing Interface Operation Codes
6311**
6312** These constants are the valid operation code parameters used
6313** as the first argument to [sqlite3_test_control()].
6314**
6315** These parameters and their meanings are subject to change
6316** without notice.  These values are for testing purposes only.
6317** Applications should not use any of these parameters or the
6318** [sqlite3_test_control()] interface.
6319*/
6320#define SQLITE_TESTCTRL_FIRST                    5
6321#define SQLITE_TESTCTRL_PRNG_SAVE                5
6322#define SQLITE_TESTCTRL_PRNG_RESTORE             6
6323#define SQLITE_TESTCTRL_PRNG_RESET               7
6324#define SQLITE_TESTCTRL_BITVEC_TEST              8
6325#define SQLITE_TESTCTRL_FAULT_INSTALL            9
6326#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS     10
6327#define SQLITE_TESTCTRL_PENDING_BYTE            11
6328#define SQLITE_TESTCTRL_ASSERT                  12
6329#define SQLITE_TESTCTRL_ALWAYS                  13
6330#define SQLITE_TESTCTRL_RESERVE                 14
6331#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
6332#define SQLITE_TESTCTRL_ISKEYWORD               16
6333#define SQLITE_TESTCTRL_SCRATCHMALLOC           17
6334#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
6335#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
6336#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
6337#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
6338#define SQLITE_TESTCTRL_BYTEORDER               22
6339#define SQLITE_TESTCTRL_ISINIT                  23
6340#define SQLITE_TESTCTRL_SORTER_MMAP             24
6341#define SQLITE_TESTCTRL_LAST                    24
6342
6343/*
6344** CAPI3REF: SQLite Runtime Status
6345**
6346** ^This interface is used to retrieve runtime status information
6347** about the performance of SQLite, and optionally to reset various
6348** highwater marks.  ^The first argument is an integer code for
6349** the specific parameter to measure.  ^(Recognized integer codes
6350** are of the form [status parameters | SQLITE_STATUS_...].)^
6351** ^The current value of the parameter is returned into *pCurrent.
6352** ^The highest recorded value is returned in *pHighwater.  ^If the
6353** resetFlag is true, then the highest record value is reset after
6354** *pHighwater is written.  ^(Some parameters do not record the highest
6355** value.  For those parameters
6356** nothing is written into *pHighwater and the resetFlag is ignored.)^
6357** ^(Other parameters record only the highwater mark and not the current
6358** value.  For these latter parameters nothing is written into *pCurrent.)^
6359**
6360** ^The sqlite3_status() routine returns SQLITE_OK on success and a
6361** non-zero [error code] on failure.
6362**
6363** This routine is threadsafe but is not atomic.  This routine can be
6364** called while other threads are running the same or different SQLite
6365** interfaces.  However the values returned in *pCurrent and
6366** *pHighwater reflect the status of SQLite at different points in time
6367** and it is possible that another thread might change the parameter
6368** in between the times when *pCurrent and *pHighwater are written.
6369**
6370** See also: [sqlite3_db_status()]
6371*/
6372SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
6373
6374
6375/*
6376** CAPI3REF: Status Parameters
6377** KEYWORDS: {status parameters}
6378**
6379** These integer constants designate various run-time status parameters
6380** that can be returned by [sqlite3_status()].
6381**
6382** <dl>
6383** [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
6384** <dd>This parameter is the current amount of memory checked out
6385** using [sqlite3_malloc()], either directly or indirectly.  The
6386** figure includes calls made to [sqlite3_malloc()] by the application
6387** and internal memory usage by the SQLite library.  Scratch memory
6388** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
6389** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
6390** this parameter.  The amount returned is the sum of the allocation
6391** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
6392**
6393** [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
6394** <dd>This parameter records the largest memory allocation request
6395** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their
6396** internal equivalents).  Only the value returned in the
6397** *pHighwater parameter to [sqlite3_status()] is of interest.
6398** The value written into the *pCurrent parameter is undefined.</dd>)^
6399**
6400** [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
6401** <dd>This parameter records the number of separate memory allocations
6402** currently checked out.</dd>)^
6403**
6404** [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
6405** <dd>This parameter returns the number of pages used out of the
6406** [pagecache memory allocator] that was configured using
6407** [SQLITE_CONFIG_PAGECACHE].  The
6408** value returned is in pages, not in bytes.</dd>)^
6409**
6410** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
6411** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
6412** <dd>This parameter returns the number of bytes of page cache
6413** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
6414** buffer and where forced to overflow to [sqlite3_malloc()].  The
6415** returned value includes allocations that overflowed because they
6416** where too large (they were larger than the "sz" parameter to
6417** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because
6418** no space was left in the page cache.</dd>)^
6419**
6420** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
6421** <dd>This parameter records the largest memory allocation request
6422** handed to [pagecache memory allocator].  Only the value returned in the
6423** *pHighwater parameter to [sqlite3_status()] is of interest.
6424** The value written into the *pCurrent parameter is undefined.</dd>)^
6425**
6426** [[SQLITE_STATUS_SCRATCH_USED]] ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
6427** <dd>This parameter returns the number of allocations used out of the
6428** [scratch memory allocator] configured using
6429** [SQLITE_CONFIG_SCRATCH].  The value returned is in allocations, not
6430** in bytes.  Since a single thread may only have one scratch allocation
6431** outstanding at time, this parameter also reports the number of threads
6432** using scratch memory at the same time.</dd>)^
6433**
6434** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
6435** <dd>This parameter returns the number of bytes of scratch memory
6436** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
6437** buffer and where forced to overflow to [sqlite3_malloc()].  The values
6438** returned include overflows because the requested allocation was too
6439** larger (that is, because the requested allocation was larger than the
6440** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
6441** slots were available.
6442** </dd>)^
6443**
6444** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
6445** <dd>This parameter records the largest memory allocation request
6446** handed to [scratch memory allocator].  Only the value returned in the
6447** *pHighwater parameter to [sqlite3_status()] is of interest.
6448** The value written into the *pCurrent parameter is undefined.</dd>)^
6449**
6450** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
6451** <dd>This parameter records the deepest parser stack.  It is only
6452** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
6453** </dl>
6454**
6455** New status parameters may be added from time to time.
6456*/
6457#define SQLITE_STATUS_MEMORY_USED          0
6458#define SQLITE_STATUS_PAGECACHE_USED       1
6459#define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
6460#define SQLITE_STATUS_SCRATCH_USED         3
6461#define SQLITE_STATUS_SCRATCH_OVERFLOW     4
6462#define SQLITE_STATUS_MALLOC_SIZE          5
6463#define SQLITE_STATUS_PARSER_STACK         6
6464#define SQLITE_STATUS_PAGECACHE_SIZE       7
6465#define SQLITE_STATUS_SCRATCH_SIZE         8
6466#define SQLITE_STATUS_MALLOC_COUNT         9
6467
6468/*
6469** CAPI3REF: Database Connection Status
6470**
6471** ^This interface is used to retrieve runtime status information
6472** about a single [database connection].  ^The first argument is the
6473** database connection object to be interrogated.  ^The second argument
6474** is an integer constant, taken from the set of
6475** [SQLITE_DBSTATUS options], that
6476** determines the parameter to interrogate.  The set of
6477** [SQLITE_DBSTATUS options] is likely
6478** to grow in future releases of SQLite.
6479**
6480** ^The current value of the requested parameter is written into *pCur
6481** and the highest instantaneous value is written into *pHiwtr.  ^If
6482** the resetFlg is true, then the highest instantaneous value is
6483** reset back down to the current value.
6484**
6485** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
6486** non-zero [error code] on failure.
6487**
6488** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
6489*/
6490SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
6491
6492/*
6493** CAPI3REF: Status Parameters for database connections
6494** KEYWORDS: {SQLITE_DBSTATUS options}
6495**
6496** These constants are the available integer "verbs" that can be passed as
6497** the second argument to the [sqlite3_db_status()] interface.
6498**
6499** New verbs may be added in future releases of SQLite. Existing verbs
6500** might be discontinued. Applications should check the return code from
6501** [sqlite3_db_status()] to make sure that the call worked.
6502** The [sqlite3_db_status()] interface will return a non-zero error code
6503** if a discontinued or unsupported verb is invoked.
6504**
6505** <dl>
6506** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
6507** <dd>This parameter returns the number of lookaside memory slots currently
6508** checked out.</dd>)^
6509**
6510** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
6511** <dd>This parameter returns the number malloc attempts that were
6512** satisfied using lookaside memory. Only the high-water value is meaningful;
6513** the current value is always zero.)^
6514**
6515** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
6516** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
6517** <dd>This parameter returns the number malloc attempts that might have
6518** been satisfied using lookaside memory but failed due to the amount of
6519** memory requested being larger than the lookaside slot size.
6520** Only the high-water value is meaningful;
6521** the current value is always zero.)^
6522**
6523** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
6524** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
6525** <dd>This parameter returns the number malloc attempts that might have
6526** been satisfied using lookaside memory but failed due to all lookaside
6527** memory already being in use.
6528** Only the high-water value is meaningful;
6529** the current value is always zero.)^
6530**
6531** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
6532** <dd>This parameter returns the approximate number of bytes of heap
6533** memory used by all pager caches associated with the database connection.)^
6534** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
6535**
6536** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
6537** <dd>This parameter returns the approximate number of bytes of heap
6538** memory used to store the schema for all databases associated
6539** with the connection - main, temp, and any [ATTACH]-ed databases.)^
6540** ^The full amount of memory used by the schemas is reported, even if the
6541** schema memory is shared with other database connections due to
6542** [shared cache mode] being enabled.
6543** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.
6544**
6545** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
6546** <dd>This parameter returns the approximate number of bytes of heap
6547** and lookaside memory used by all prepared statements associated with
6548** the database connection.)^
6549** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0.
6550** </dd>
6551**
6552** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
6553** <dd>This parameter returns the number of pager cache hits that have
6554** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
6555** is always 0.
6556** </dd>
6557**
6558** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
6559** <dd>This parameter returns the number of pager cache misses that have
6560** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
6561** is always 0.
6562** </dd>
6563**
6564** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(<dt>SQLITE_DBSTATUS_CACHE_WRITE</dt>
6565** <dd>This parameter returns the number of dirty cache entries that have
6566** been written to disk. Specifically, the number of pages written to the
6567** wal file in wal mode databases, or the number of pages written to the
6568** database file in rollback mode databases. Any pages written as part of
6569** transaction rollback or database recovery operations are not included.
6570** If an IO or other error occurs while writing a page to disk, the effect
6571** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The
6572** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0.
6573** </dd>
6574**
6575** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
6576** <dd>This parameter returns zero for the current value if and only if
6577** all foreign key constraints (deferred or immediate) have been
6578** resolved.)^  ^The highwater mark is always 0.
6579** </dd>
6580** </dl>
6581*/
6582#define SQLITE_DBSTATUS_LOOKASIDE_USED       0
6583#define SQLITE_DBSTATUS_CACHE_USED           1
6584#define SQLITE_DBSTATUS_SCHEMA_USED          2
6585#define SQLITE_DBSTATUS_STMT_USED            3
6586#define SQLITE_DBSTATUS_LOOKASIDE_HIT        4
6587#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE  5
6588#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6
6589#define SQLITE_DBSTATUS_CACHE_HIT            7
6590#define SQLITE_DBSTATUS_CACHE_MISS           8
6591#define SQLITE_DBSTATUS_CACHE_WRITE          9
6592#define SQLITE_DBSTATUS_DEFERRED_FKS        10
6593#define SQLITE_DBSTATUS_MAX                 10   /* Largest defined DBSTATUS */
6594
6595
6596/*
6597** CAPI3REF: Prepared Statement Status
6598**
6599** ^(Each prepared statement maintains various
6600** [SQLITE_STMTSTATUS counters] that measure the number
6601** of times it has performed specific operations.)^  These counters can
6602** be used to monitor the performance characteristics of the prepared
6603** statements.  For example, if the number of table steps greatly exceeds
6604** the number of table searches or result rows, that would tend to indicate
6605** that the prepared statement is using a full table scan rather than
6606** an index.
6607**
6608** ^(This interface is used to retrieve and reset counter values from
6609** a [prepared statement].  The first argument is the prepared statement
6610** object to be interrogated.  The second argument
6611** is an integer code for a specific [SQLITE_STMTSTATUS counter]
6612** to be interrogated.)^
6613** ^The current value of the requested counter is returned.
6614** ^If the resetFlg is true, then the counter is reset to zero after this
6615** interface call returns.
6616**
6617** See also: [sqlite3_status()] and [sqlite3_db_status()].
6618*/
6619SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
6620
6621/*
6622** CAPI3REF: Status Parameters for prepared statements
6623** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters}
6624**
6625** These preprocessor macros define integer codes that name counter
6626** values associated with the [sqlite3_stmt_status()] interface.
6627** The meanings of the various counters are as follows:
6628**
6629** <dl>
6630** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
6631** <dd>^This is the number of times that SQLite has stepped forward in
6632** a table as part of a full table scan.  Large numbers for this counter
6633** may indicate opportunities for performance improvement through
6634** careful use of indices.</dd>
6635**
6636** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
6637** <dd>^This is the number of sort operations that have occurred.
6638** A non-zero value in this counter may indicate an opportunity to
6639** improvement performance through careful use of indices.</dd>
6640**
6641** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
6642** <dd>^This is the number of rows inserted into transient indices that
6643** were created automatically in order to help joins run faster.
6644** A non-zero value in this counter may indicate an opportunity to
6645** improvement performance by adding permanent indices that do not
6646** need to be reinitialized each time the statement is run.</dd>
6647**
6648** [[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt>
6649** <dd>^This is the number of virtual machine operations executed
6650** by the prepared statement if that number is less than or equal
6651** to 2147483647.  The number of virtual machine operations can be
6652** used as a proxy for the total work done by the prepared statement.
6653** If the number of virtual machine operations exceeds 2147483647
6654** then the value returned by this statement status code is undefined.
6655** </dd>
6656** </dl>
6657*/
6658#define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
6659#define SQLITE_STMTSTATUS_SORT              2
6660#define SQLITE_STMTSTATUS_AUTOINDEX         3
6661#define SQLITE_STMTSTATUS_VM_STEP           4
6662
6663/*
6664** CAPI3REF: Custom Page Cache Object
6665**
6666** The sqlite3_pcache type is opaque.  It is implemented by
6667** the pluggable module.  The SQLite core has no knowledge of
6668** its size or internal structure and never deals with the
6669** sqlite3_pcache object except by holding and passing pointers
6670** to the object.
6671**
6672** See [sqlite3_pcache_methods2] for additional information.
6673*/
6674typedef struct sqlite3_pcache sqlite3_pcache;
6675
6676/*
6677** CAPI3REF: Custom Page Cache Object
6678**
6679** The sqlite3_pcache_page object represents a single page in the
6680** page cache.  The page cache will allocate instances of this
6681** object.  Various methods of the page cache use pointers to instances
6682** of this object as parameters or as their return value.
6683**
6684** See [sqlite3_pcache_methods2] for additional information.
6685*/
6686typedef struct sqlite3_pcache_page sqlite3_pcache_page;
6687struct sqlite3_pcache_page {
6688  void *pBuf;        /* The content of the page */
6689  void *pExtra;      /* Extra information associated with the page */
6690};
6691
6692/*
6693** CAPI3REF: Application Defined Page Cache.
6694** KEYWORDS: {page cache}
6695**
6696** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can
6697** register an alternative page cache implementation by passing in an
6698** instance of the sqlite3_pcache_methods2 structure.)^
6699** In many applications, most of the heap memory allocated by
6700** SQLite is used for the page cache.
6701** By implementing a
6702** custom page cache using this API, an application can better control
6703** the amount of memory consumed by SQLite, the way in which
6704** that memory is allocated and released, and the policies used to
6705** determine exactly which parts of a database file are cached and for
6706** how long.
6707**
6708** The alternative page cache mechanism is an
6709** extreme measure that is only needed by the most demanding applications.
6710** The built-in page cache is recommended for most uses.
6711**
6712** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
6713** internal buffer by SQLite within the call to [sqlite3_config].  Hence
6714** the application may discard the parameter after the call to
6715** [sqlite3_config()] returns.)^
6716**
6717** [[the xInit() page cache method]]
6718** ^(The xInit() method is called once for each effective
6719** call to [sqlite3_initialize()])^
6720** (usually only once during the lifetime of the process). ^(The xInit()
6721** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
6722** The intent of the xInit() method is to set up global data structures
6723** required by the custom page cache implementation.
6724** ^(If the xInit() method is NULL, then the
6725** built-in default page cache is used instead of the application defined
6726** page cache.)^
6727**
6728** [[the xShutdown() page cache method]]
6729** ^The xShutdown() method is called by [sqlite3_shutdown()].
6730** It can be used to clean up
6731** any outstanding resources before process shutdown, if required.
6732** ^The xShutdown() method may be NULL.
6733**
6734** ^SQLite automatically serializes calls to the xInit method,
6735** so the xInit method need not be threadsafe.  ^The
6736** xShutdown method is only called from [sqlite3_shutdown()] so it does
6737** not need to be threadsafe either.  All other methods must be threadsafe
6738** in multithreaded applications.
6739**
6740** ^SQLite will never invoke xInit() more than once without an intervening
6741** call to xShutdown().
6742**
6743** [[the xCreate() page cache methods]]
6744** ^SQLite invokes the xCreate() method to construct a new cache instance.
6745** SQLite will typically create one cache instance for each open database file,
6746** though this is not guaranteed. ^The
6747** first parameter, szPage, is the size in bytes of the pages that must
6748** be allocated by the cache.  ^szPage will always a power of two.  ^The
6749** second parameter szExtra is a number of bytes of extra storage
6750** associated with each page cache entry.  ^The szExtra parameter will
6751** a number less than 250.  SQLite will use the
6752** extra szExtra bytes on each page to store metadata about the underlying
6753** database page on disk.  The value passed into szExtra depends
6754** on the SQLite version, the target platform, and how SQLite was compiled.
6755** ^The third argument to xCreate(), bPurgeable, is true if the cache being
6756** created will be used to cache database pages of a file stored on disk, or
6757** false if it is used for an in-memory database. The cache implementation
6758** does not have to do anything special based with the value of bPurgeable;
6759** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
6760** never invoke xUnpin() except to deliberately delete a page.
6761** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
6762** false will always have the "discard" flag set to true.
6763** ^Hence, a cache created with bPurgeable false will
6764** never contain any unpinned pages.
6765**
6766** [[the xCachesize() page cache method]]
6767** ^(The xCachesize() method may be called at any time by SQLite to set the
6768** suggested maximum cache-size (number of pages stored by) the cache
6769** instance passed as the first argument. This is the value configured using
6770** the SQLite "[PRAGMA cache_size]" command.)^  As with the bPurgeable
6771** parameter, the implementation is not required to do anything with this
6772** value; it is advisory only.
6773**
6774** [[the xPagecount() page cache methods]]
6775** The xPagecount() method must return the number of pages currently
6776** stored in the cache, both pinned and unpinned.
6777**
6778** [[the xFetch() page cache methods]]
6779** The xFetch() method locates a page in the cache and returns a pointer to
6780** an sqlite3_pcache_page object associated with that page, or a NULL pointer.
6781** The pBuf element of the returned sqlite3_pcache_page object will be a
6782** pointer to a buffer of szPage bytes used to store the content of a
6783** single database page.  The pExtra element of sqlite3_pcache_page will be
6784** a pointer to the szExtra bytes of extra storage that SQLite has requested
6785** for each entry in the page cache.
6786**
6787** The page to be fetched is determined by the key. ^The minimum key value
6788** is 1.  After it has been retrieved using xFetch, the page is considered
6789** to be "pinned".
6790**
6791** If the requested page is already in the page cache, then the page cache
6792** implementation must return a pointer to the page buffer with its content
6793** intact.  If the requested page is not already in the cache, then the
6794** cache implementation should use the value of the createFlag
6795** parameter to help it determined what action to take:
6796**
6797** <table border=1 width=85% align=center>
6798** <tr><th> createFlag <th> Behavior when page is not already in cache
6799** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
6800** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
6801**                 Otherwise return NULL.
6802** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
6803**                 NULL if allocating a new page is effectively impossible.
6804** </table>
6805**
6806** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  SQLite
6807** will only use a createFlag of 2 after a prior call with a createFlag of 1
6808** failed.)^  In between the to xFetch() calls, SQLite may
6809** attempt to unpin one or more cache pages by spilling the content of
6810** pinned pages to disk and synching the operating system disk cache.
6811**
6812** [[the xUnpin() page cache method]]
6813** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
6814** as its second argument.  If the third parameter, discard, is non-zero,
6815** then the page must be evicted from the cache.
6816** ^If the discard parameter is
6817** zero, then the page may be discarded or retained at the discretion of
6818** page cache implementation. ^The page cache implementation
6819** may choose to evict unpinned pages at any time.
6820**
6821** The cache must not perform any reference counting. A single
6822** call to xUnpin() unpins the page regardless of the number of prior calls
6823** to xFetch().
6824**
6825** [[the xRekey() page cache methods]]
6826** The xRekey() method is used to change the key value associated with the
6827** page passed as the second argument. If the cache
6828** previously contains an entry associated with newKey, it must be
6829** discarded. ^Any prior cache entry associated with newKey is guaranteed not
6830** to be pinned.
6831**
6832** When SQLite calls the xTruncate() method, the cache must discard all
6833** existing cache entries with page numbers (keys) greater than or equal
6834** to the value of the iLimit parameter passed to xTruncate(). If any
6835** of these pages are pinned, they are implicitly unpinned, meaning that
6836** they can be safely discarded.
6837**
6838** [[the xDestroy() page cache method]]
6839** ^The xDestroy() method is used to delete a cache allocated by xCreate().
6840** All resources associated with the specified cache should be freed. ^After
6841** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
6842** handle invalid, and will not use it with any other sqlite3_pcache_methods2
6843** functions.
6844**
6845** [[the xShrink() page cache method]]
6846** ^SQLite invokes the xShrink() method when it wants the page cache to
6847** free up as much of heap memory as possible.  The page cache implementation
6848** is not obligated to free any memory, but well-behaved implementations should
6849** do their best.
6850*/
6851typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
6852struct sqlite3_pcache_methods2 {
6853  int iVersion;
6854  void *pArg;
6855  int (*xInit)(void*);
6856  void (*xShutdown)(void*);
6857  sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable);
6858  void (*xCachesize)(sqlite3_pcache*, int nCachesize);
6859  int (*xPagecount)(sqlite3_pcache*);
6860  sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
6861  void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard);
6862  void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*,
6863      unsigned oldKey, unsigned newKey);
6864  void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
6865  void (*xDestroy)(sqlite3_pcache*);
6866  void (*xShrink)(sqlite3_pcache*);
6867};
6868
6869/*
6870** This is the obsolete pcache_methods object that has now been replaced
6871** by sqlite3_pcache_methods2.  This object is not used by SQLite.  It is
6872** retained in the header file for backwards compatibility only.
6873*/
6874typedef struct sqlite3_pcache_methods sqlite3_pcache_methods;
6875struct sqlite3_pcache_methods {
6876  void *pArg;
6877  int (*xInit)(void*);
6878  void (*xShutdown)(void*);
6879  sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable);
6880  void (*xCachesize)(sqlite3_pcache*, int nCachesize);
6881  int (*xPagecount)(sqlite3_pcache*);
6882  void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
6883  void (*xUnpin)(sqlite3_pcache*, void*, int discard);
6884  void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey);
6885  void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
6886  void (*xDestroy)(sqlite3_pcache*);
6887};
6888
6889
6890/*
6891** CAPI3REF: Online Backup Object
6892**
6893** The sqlite3_backup object records state information about an ongoing
6894** online backup operation.  ^The sqlite3_backup object is created by
6895** a call to [sqlite3_backup_init()] and is destroyed by a call to
6896** [sqlite3_backup_finish()].
6897**
6898** See Also: [Using the SQLite Online Backup API]
6899*/
6900typedef struct sqlite3_backup sqlite3_backup;
6901
6902/*
6903** CAPI3REF: Online Backup API.
6904**
6905** The backup API copies the content of one database into another.
6906** It is useful either for creating backups of databases or
6907** for copying in-memory databases to or from persistent files.
6908**
6909** See Also: [Using the SQLite Online Backup API]
6910**
6911** ^SQLite holds a write transaction open on the destination database file
6912** for the duration of the backup operation.
6913** ^The source database is read-locked only while it is being read;
6914** it is not locked continuously for the entire backup operation.
6915** ^Thus, the backup may be performed on a live source database without
6916** preventing other database connections from
6917** reading or writing to the source database while the backup is underway.
6918**
6919** ^(To perform a backup operation:
6920**   <ol>
6921**     <li><b>sqlite3_backup_init()</b> is called once to initialize the
6922**         backup,
6923**     <li><b>sqlite3_backup_step()</b> is called one or more times to transfer
6924**         the data between the two databases, and finally
6925**     <li><b>sqlite3_backup_finish()</b> is called to release all resources
6926**         associated with the backup operation.
6927**   </ol>)^
6928** There should be exactly one call to sqlite3_backup_finish() for each
6929** successful call to sqlite3_backup_init().
6930**
6931** [[sqlite3_backup_init()]] <b>sqlite3_backup_init()</b>
6932**
6933** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the
6934** [database connection] associated with the destination database
6935** and the database name, respectively.
6936** ^The database name is "main" for the main database, "temp" for the
6937** temporary database, or the name specified after the AS keyword in
6938** an [ATTACH] statement for an attached database.
6939** ^The S and M arguments passed to
6940** sqlite3_backup_init(D,N,S,M) identify the [database connection]
6941** and database name of the source database, respectively.
6942** ^The source and destination [database connections] (parameters S and D)
6943** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
6944** an error.
6945**
6946** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
6947** returned and an error code and error message are stored in the
6948** destination [database connection] D.
6949** ^The error code and message for the failed call to sqlite3_backup_init()
6950** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or
6951** [sqlite3_errmsg16()] functions.
6952** ^A successful call to sqlite3_backup_init() returns a pointer to an
6953** [sqlite3_backup] object.
6954** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and
6955** sqlite3_backup_finish() functions to perform the specified backup
6956** operation.
6957**
6958** [[sqlite3_backup_step()]] <b>sqlite3_backup_step()</b>
6959**
6960** ^Function sqlite3_backup_step(B,N) will copy up to N pages between
6961** the source and destination databases specified by [sqlite3_backup] object B.
6962** ^If N is negative, all remaining source pages are copied.
6963** ^If sqlite3_backup_step(B,N) successfully copies N pages and there
6964** are still more pages to be copied, then the function returns [SQLITE_OK].
6965** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
6966** from source to destination, then it returns [SQLITE_DONE].
6967** ^If an error occurs while running sqlite3_backup_step(B,N),
6968** then an [error code] is returned. ^As well as [SQLITE_OK] and
6969** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY],
6970** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an
6971** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code.
6972**
6973** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if
6974** <ol>
6975** <li> the destination database was opened read-only, or
6976** <li> the destination database is using write-ahead-log journaling
6977** and the destination and source page sizes differ, or
6978** <li> the destination database is an in-memory database and the
6979** destination and source page sizes differ.
6980** </ol>)^
6981**
6982** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
6983** the [sqlite3_busy_handler | busy-handler function]
6984** is invoked (if one is specified). ^If the
6985** busy-handler returns non-zero before the lock is available, then
6986** [SQLITE_BUSY] is returned to the caller. ^In this case the call to
6987** sqlite3_backup_step() can be retried later. ^If the source
6988** [database connection]
6989** is being used to write to the source database when sqlite3_backup_step()
6990** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
6991** case the call to sqlite3_backup_step() can be retried later on. ^(If
6992** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or
6993** [SQLITE_READONLY] is returned, then
6994** there is no point in retrying the call to sqlite3_backup_step(). These
6995** errors are considered fatal.)^  The application must accept
6996** that the backup operation has failed and pass the backup operation handle
6997** to the sqlite3_backup_finish() to release associated resources.
6998**
6999** ^The first call to sqlite3_backup_step() obtains an exclusive lock
7000** on the destination file. ^The exclusive lock is not released until either
7001** sqlite3_backup_finish() is called or the backup operation is complete
7002** and sqlite3_backup_step() returns [SQLITE_DONE].  ^Every call to
7003** sqlite3_backup_step() obtains a [shared lock] on the source database that
7004** lasts for the duration of the sqlite3_backup_step() call.
7005** ^Because the source database is not locked between calls to
7006** sqlite3_backup_step(), the source database may be modified mid-way
7007** through the backup process.  ^If the source database is modified by an
7008** external process or via a database connection other than the one being
7009** used by the backup operation, then the backup will be automatically
7010** restarted by the next call to sqlite3_backup_step(). ^If the source
7011** database is modified by the using the same database connection as is used
7012** by the backup operation, then the backup database is automatically
7013** updated at the same time.
7014**
7015** [[sqlite3_backup_finish()]] <b>sqlite3_backup_finish()</b>
7016**
7017** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the
7018** application wishes to abandon the backup operation, the application
7019** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish().
7020** ^The sqlite3_backup_finish() interfaces releases all
7021** resources associated with the [sqlite3_backup] object.
7022** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
7023** active write-transaction on the destination database is rolled back.
7024** The [sqlite3_backup] object is invalid
7025** and may not be used following a call to sqlite3_backup_finish().
7026**
7027** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
7028** sqlite3_backup_step() errors occurred, regardless or whether or not
7029** sqlite3_backup_step() completed.
7030** ^If an out-of-memory condition or IO error occurred during any prior
7031** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
7032** sqlite3_backup_finish() returns the corresponding [error code].
7033**
7034** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step()
7035** is not a permanent error and does not affect the return value of
7036** sqlite3_backup_finish().
7037**
7038** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]]
7039** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
7040**
7041** ^Each call to sqlite3_backup_step() sets two values inside
7042** the [sqlite3_backup] object: the number of pages still to be backed
7043** up and the total number of pages in the source database file.
7044** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
7045** retrieve these two values, respectively.
7046**
7047** ^The values returned by these functions are only updated by
7048** sqlite3_backup_step(). ^If the source database is modified during a backup
7049** operation, then the values are not updated to account for any extra
7050** pages that need to be updated or the size of the source database file
7051** changing.
7052**
7053** <b>Concurrent Usage of Database Handles</b>
7054**
7055** ^The source [database connection] may be used by the application for other
7056** purposes while a backup operation is underway or being initialized.
7057** ^If SQLite is compiled and configured to support threadsafe database
7058** connections, then the source database connection may be used concurrently
7059** from within other threads.
7060**
7061** However, the application must guarantee that the destination
7062** [database connection] is not passed to any other API (by any thread) after
7063** sqlite3_backup_init() is called and before the corresponding call to
7064** sqlite3_backup_finish().  SQLite does not currently check to see
7065** if the application incorrectly accesses the destination [database connection]
7066** and so no error code is reported, but the operations may malfunction
7067** nevertheless.  Use of the destination database connection while a
7068** backup is in progress might also also cause a mutex deadlock.
7069**
7070** If running in [shared cache mode], the application must
7071** guarantee that the shared cache used by the destination database
7072** is not accessed while the backup is running. In practice this means
7073** that the application must guarantee that the disk file being
7074** backed up to is not accessed by any connection within the process,
7075** not just the specific connection that was passed to sqlite3_backup_init().
7076**
7077** The [sqlite3_backup] object itself is partially threadsafe. Multiple
7078** threads may safely make multiple concurrent calls to sqlite3_backup_step().
7079** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount()
7080** APIs are not strictly speaking threadsafe. If they are invoked at the
7081** same time as another thread is invoking sqlite3_backup_step() it is
7082** possible that they return invalid values.
7083*/
7084SQLITE_API sqlite3_backup *sqlite3_backup_init(
7085  sqlite3 *pDest,                        /* Destination database handle */
7086  const char *zDestName,                 /* Destination database name */
7087  sqlite3 *pSource,                      /* Source database handle */
7088  const char *zSourceName                /* Source database name */
7089);
7090SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
7091SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
7092SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
7093SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
7094
7095/*
7096** CAPI3REF: Unlock Notification
7097**
7098** ^When running in shared-cache mode, a database operation may fail with
7099** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
7100** individual tables within the shared-cache cannot be obtained. See
7101** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
7102** ^This API may be used to register a callback that SQLite will invoke
7103** when the connection currently holding the required lock relinquishes it.
7104** ^This API is only available if the library was compiled with the
7105** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
7106**
7107** See Also: [Using the SQLite Unlock Notification Feature].
7108**
7109** ^Shared-cache locks are released when a database connection concludes
7110** its current transaction, either by committing it or rolling it back.
7111**
7112** ^When a connection (known as the blocked connection) fails to obtain a
7113** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
7114** identity of the database connection (the blocking connection) that
7115** has locked the required resource is stored internally. ^After an
7116** application receives an SQLITE_LOCKED error, it may call the
7117** sqlite3_unlock_notify() method with the blocked connection handle as
7118** the first argument to register for a callback that will be invoked
7119** when the blocking connections current transaction is concluded. ^The
7120** callback is invoked from within the [sqlite3_step] or [sqlite3_close]
7121** call that concludes the blocking connections transaction.
7122**
7123** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
7124** there is a chance that the blocking connection will have already
7125** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
7126** If this happens, then the specified callback is invoked immediately,
7127** from within the call to sqlite3_unlock_notify().)^
7128**
7129** ^If the blocked connection is attempting to obtain a write-lock on a
7130** shared-cache table, and more than one other connection currently holds
7131** a read-lock on the same table, then SQLite arbitrarily selects one of
7132** the other connections to use as the blocking connection.
7133**
7134** ^(There may be at most one unlock-notify callback registered by a
7135** blocked connection. If sqlite3_unlock_notify() is called when the
7136** blocked connection already has a registered unlock-notify callback,
7137** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
7138** called with a NULL pointer as its second argument, then any existing
7139** unlock-notify callback is canceled. ^The blocked connections
7140** unlock-notify callback may also be canceled by closing the blocked
7141** connection using [sqlite3_close()].
7142**
7143** The unlock-notify callback is not reentrant. If an application invokes
7144** any sqlite3_xxx API functions from within an unlock-notify callback, a
7145** crash or deadlock may be the result.
7146**
7147** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always
7148** returns SQLITE_OK.
7149**
7150** <b>Callback Invocation Details</b>
7151**
7152** When an unlock-notify callback is registered, the application provides a
7153** single void* pointer that is passed to the callback when it is invoked.
7154** However, the signature of the callback function allows SQLite to pass
7155** it an array of void* context pointers. The first argument passed to
7156** an unlock-notify callback is a pointer to an array of void* pointers,
7157** and the second is the number of entries in the array.
7158**
7159** When a blocking connections transaction is concluded, there may be
7160** more than one blocked connection that has registered for an unlock-notify
7161** callback. ^If two or more such blocked connections have specified the
7162** same callback function, then instead of invoking the callback function
7163** multiple times, it is invoked once with the set of void* context pointers
7164** specified by the blocked connections bundled together into an array.
7165** This gives the application an opportunity to prioritize any actions
7166** related to the set of unblocked database connections.
7167**
7168** <b>Deadlock Detection</b>
7169**
7170** Assuming that after registering for an unlock-notify callback a
7171** database waits for the callback to be issued before taking any further
7172** action (a reasonable assumption), then using this API may cause the
7173** application to deadlock. For example, if connection X is waiting for
7174** connection Y's transaction to be concluded, and similarly connection
7175** Y is waiting on connection X's transaction, then neither connection
7176** will proceed and the system may remain deadlocked indefinitely.
7177**
7178** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock
7179** detection. ^If a given call to sqlite3_unlock_notify() would put the
7180** system in a deadlocked state, then SQLITE_LOCKED is returned and no
7181** unlock-notify callback is registered. The system is said to be in
7182** a deadlocked state if connection A has registered for an unlock-notify
7183** callback on the conclusion of connection B's transaction, and connection
7184** B has itself registered for an unlock-notify callback when connection
7185** A's transaction is concluded. ^Indirect deadlock is also detected, so
7186** the system is also considered to be deadlocked if connection B has
7187** registered for an unlock-notify callback on the conclusion of connection
7188** C's transaction, where connection C is waiting on connection A. ^Any
7189** number of levels of indirection are allowed.
7190**
7191** <b>The "DROP TABLE" Exception</b>
7192**
7193** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost
7194** always appropriate to call sqlite3_unlock_notify(). There is however,
7195** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement,
7196** SQLite checks if there are any currently executing SELECT statements
7197** that belong to the same connection. If there are, SQLITE_LOCKED is
7198** returned. In this case there is no "blocking connection", so invoking
7199** sqlite3_unlock_notify() results in the unlock-notify callback being
7200** invoked immediately. If the application then re-attempts the "DROP TABLE"
7201** or "DROP INDEX" query, an infinite loop might be the result.
7202**
7203** One way around this problem is to check the extended error code returned
7204** by an sqlite3_step() call. ^(If there is a blocking connection, then the
7205** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
7206** the special "DROP TABLE/INDEX" case, the extended error code is just
7207** SQLITE_LOCKED.)^
7208*/
7209SQLITE_API int sqlite3_unlock_notify(
7210  sqlite3 *pBlocked,                          /* Waiting connection */
7211  void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
7212  void *pNotifyArg                            /* Argument to pass to xNotify */
7213);
7214
7215
7216/*
7217** CAPI3REF: String Comparison
7218**
7219** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications
7220** and extensions to compare the contents of two buffers containing UTF-8
7221** strings in a case-independent fashion, using the same definition of "case
7222** independence" that SQLite uses internally when comparing identifiers.
7223*/
7224SQLITE_API int sqlite3_stricmp(const char *, const char *);
7225SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
7226
7227/*
7228** CAPI3REF: String Globbing
7229*
7230** ^The [sqlite3_strglob(P,X)] interface returns zero if string X matches
7231** the glob pattern P, and it returns non-zero if string X does not match
7232** the glob pattern P.  ^The definition of glob pattern matching used in
7233** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the
7234** SQL dialect used by SQLite.  ^The sqlite3_strglob(P,X) function is case
7235** sensitive.
7236**
7237** Note that this routine returns zero on a match and non-zero if the strings
7238** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
7239*/
7240SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);
7241
7242/*
7243** CAPI3REF: Error Logging Interface
7244**
7245** ^The [sqlite3_log()] interface writes a message into the [error log]
7246** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].
7247** ^If logging is enabled, the zFormat string and subsequent arguments are
7248** used with [sqlite3_snprintf()] to generate the final output string.
7249**
7250** The sqlite3_log() interface is intended for use by extensions such as
7251** virtual tables, collating functions, and SQL functions.  While there is
7252** nothing to prevent an application from calling sqlite3_log(), doing so
7253** is considered bad form.
7254**
7255** The zFormat string must not be NULL.
7256**
7257** To avoid deadlocks and other threading problems, the sqlite3_log() routine
7258** will not use dynamically allocated memory.  The log message is stored in
7259** a fixed-length buffer on the stack.  If the log message is longer than
7260** a few hundred characters, it will be truncated to the length of the
7261** buffer.
7262*/
7263SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
7264
7265/*
7266** CAPI3REF: Write-Ahead Log Commit Hook
7267**
7268** ^The [sqlite3_wal_hook()] function is used to register a callback that
7269** will be invoked each time a database connection commits data to a
7270** [write-ahead log] (i.e. whenever a transaction is committed in
7271** [journal_mode | journal_mode=WAL mode]).
7272**
7273** ^The callback is invoked by SQLite after the commit has taken place and
7274** the associated write-lock on the database released, so the implementation
7275** may read, write or [checkpoint] the database as required.
7276**
7277** ^The first parameter passed to the callback function when it is invoked
7278** is a copy of the third parameter passed to sqlite3_wal_hook() when
7279** registering the callback. ^The second is a copy of the database handle.
7280** ^The third parameter is the name of the database that was written to -
7281** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
7282** is the number of pages currently in the write-ahead log file,
7283** including those that were just committed.
7284**
7285** The callback function should normally return [SQLITE_OK].  ^If an error
7286** code is returned, that error will propagate back up through the
7287** SQLite code base to cause the statement that provoked the callback
7288** to report an error, though the commit will have still occurred. If the
7289** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value
7290** that does not correspond to any valid SQLite error code, the results
7291** are undefined.
7292**
7293** A single database handle may have at most a single write-ahead log callback
7294** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
7295** previously registered write-ahead log callback. ^Note that the
7296** [sqlite3_wal_autocheckpoint()] interface and the
7297** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
7298** those overwrite any prior [sqlite3_wal_hook()] settings.
7299*/
7300SQLITE_API void *sqlite3_wal_hook(
7301  sqlite3*,
7302  int(*)(void *,sqlite3*,const char*,int),
7303  void*
7304);
7305
7306/*
7307** CAPI3REF: Configure an auto-checkpoint
7308**
7309** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around
7310** [sqlite3_wal_hook()] that causes any database on [database connection] D
7311** to automatically [checkpoint]
7312** after committing a transaction if there are N or
7313** more frames in the [write-ahead log] file.  ^Passing zero or
7314** a negative value as the nFrame parameter disables automatic
7315** checkpoints entirely.
7316**
7317** ^The callback registered by this function replaces any existing callback
7318** registered using [sqlite3_wal_hook()].  ^Likewise, registering a callback
7319** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism
7320** configured by this function.
7321**
7322** ^The [wal_autocheckpoint pragma] can be used to invoke this interface
7323** from SQL.
7324**
7325** ^Checkpoints initiated by this mechanism are
7326** [sqlite3_wal_checkpoint_v2|PASSIVE].
7327**
7328** ^Every new [database connection] defaults to having the auto-checkpoint
7329** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT]
7330** pages.  The use of this interface
7331** is only necessary if the default setting is found to be suboptimal
7332** for a particular application.
7333*/
7334SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
7335
7336/*
7337** CAPI3REF: Checkpoint a database
7338**
7339** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X
7340** on [database connection] D to be [checkpointed].  ^If X is NULL or an
7341** empty string, then a checkpoint is run on all databases of
7342** connection D.  ^If the database connection D is not in
7343** [WAL | write-ahead log mode] then this interface is a harmless no-op.
7344** ^The [sqlite3_wal_checkpoint(D,X)] interface initiates a
7345** [sqlite3_wal_checkpoint_v2|PASSIVE] checkpoint.
7346** Use the [sqlite3_wal_checkpoint_v2()] interface to get a FULL
7347** or RESET checkpoint.
7348**
7349** ^The [wal_checkpoint pragma] can be used to invoke this interface
7350** from SQL.  ^The [sqlite3_wal_autocheckpoint()] interface and the
7351** [wal_autocheckpoint pragma] can be used to cause this interface to be
7352** run whenever the WAL reaches a certain size threshold.
7353**
7354** See also: [sqlite3_wal_checkpoint_v2()]
7355*/
7356SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
7357
7358/*
7359** CAPI3REF: Checkpoint a database
7360**
7361** Run a checkpoint operation on WAL database zDb attached to database
7362** handle db. The specific operation is determined by the value of the
7363** eMode parameter:
7364**
7365** <dl>
7366** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
7367**   Checkpoint as many frames as possible without waiting for any database
7368**   readers or writers to finish. Sync the db file if all frames in the log
7369**   are checkpointed. This mode is the same as calling
7370**   sqlite3_wal_checkpoint(). The [sqlite3_busy_handler|busy-handler callback]
7371**   is never invoked.
7372**
7373** <dt>SQLITE_CHECKPOINT_FULL<dd>
7374**   This mode blocks (it invokes the
7375**   [sqlite3_busy_handler|busy-handler callback]) until there is no
7376**   database writer and all readers are reading from the most recent database
7377**   snapshot. It then checkpoints all frames in the log file and syncs the
7378**   database file. This call blocks database writers while it is running,
7379**   but not database readers.
7380**
7381** <dt>SQLITE_CHECKPOINT_RESTART<dd>
7382**   This mode works the same way as SQLITE_CHECKPOINT_FULL, except after
7383**   checkpointing the log file it blocks (calls the
7384**   [sqlite3_busy_handler|busy-handler callback])
7385**   until all readers are reading from the database file only. This ensures
7386**   that the next client to write to the database file restarts the log file
7387**   from the beginning. This call blocks database writers while it is running,
7388**   but not database readers.
7389** </dl>
7390**
7391** If pnLog is not NULL, then *pnLog is set to the total number of frames in
7392** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7393** the total number of checkpointed frames (including any that were already
7394** checkpointed when this function is called). *pnLog and *pnCkpt may be
7395** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
7396** If no values are available because of an error, they are both set to -1
7397** before returning to communicate this to the caller.
7398**
7399** All calls obtain an exclusive "checkpoint" lock on the database file. If
7400** any other process is running a checkpoint operation at the same time, the
7401** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a
7402** busy-handler configured, it will not be invoked in this case.
7403**
7404** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive
7405** "writer" lock on the database file. If the writer lock cannot be obtained
7406** immediately, and a busy-handler is configured, it is invoked and the writer
7407** lock retried until either the busy-handler returns 0 or the lock is
7408** successfully obtained. The busy-handler is also invoked while waiting for
7409** database readers as described above. If the busy-handler returns 0 before
7410** the writer lock is obtained or while waiting for database readers, the
7411** checkpoint operation proceeds from that point in the same way as
7412** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
7413** without blocking any further. SQLITE_BUSY is returned in this case.
7414**
7415** If parameter zDb is NULL or points to a zero length string, then the
7416** specified operation is attempted on all WAL databases. In this case the
7417** values written to output parameters *pnLog and *pnCkpt are undefined. If
7418** an SQLITE_BUSY error is encountered when processing one or more of the
7419** attached WAL databases, the operation is still attempted on any remaining
7420** attached databases and SQLITE_BUSY is returned to the caller. If any other
7421** error occurs while processing an attached database, processing is abandoned
7422** and the error code returned to the caller immediately. If no error
7423** (SQLITE_BUSY or otherwise) is encountered while processing the attached
7424** databases, SQLITE_OK is returned.
7425**
7426** If database zDb is the name of an attached database that is not in WAL
7427** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
7428** zDb is not NULL (or a zero length string) and is not the name of any
7429** attached database, SQLITE_ERROR is returned to the caller.
7430*/
7431SQLITE_API int sqlite3_wal_checkpoint_v2(
7432  sqlite3 *db,                    /* Database handle */
7433  const char *zDb,                /* Name of attached database (or NULL) */
7434  int eMode,                      /* SQLITE_CHECKPOINT_* value */
7435  int *pnLog,                     /* OUT: Size of WAL log in frames */
7436  int *pnCkpt                     /* OUT: Total number of frames checkpointed */
7437);
7438
7439/*
7440** CAPI3REF: Checkpoint operation parameters
7441**
7442** These constants can be used as the 3rd parameter to
7443** [sqlite3_wal_checkpoint_v2()].  See the [sqlite3_wal_checkpoint_v2()]
7444** documentation for additional information about the meaning and use of
7445** each of these values.
7446*/
7447#define SQLITE_CHECKPOINT_PASSIVE 0
7448#define SQLITE_CHECKPOINT_FULL    1
7449#define SQLITE_CHECKPOINT_RESTART 2
7450
7451/*
7452** CAPI3REF: Virtual Table Interface Configuration
7453**
7454** This function may be called by either the [xConnect] or [xCreate] method
7455** of a [virtual table] implementation to configure
7456** various facets of the virtual table interface.
7457**
7458** If this interface is invoked outside the context of an xConnect or
7459** xCreate virtual table method then the behavior is undefined.
7460**
7461** At present, there is only one option that may be configured using
7462** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].)  Further options
7463** may be added in the future.
7464*/
7465SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
7466
7467/*
7468** CAPI3REF: Virtual Table Configuration Options
7469**
7470** These macros define the various options to the
7471** [sqlite3_vtab_config()] interface that [virtual table] implementations
7472** can use to customize and optimize their behavior.
7473**
7474** <dl>
7475** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT
7476** <dd>Calls of the form
7477** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
7478** where X is an integer.  If X is zero, then the [virtual table] whose
7479** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not
7480** support constraints.  In this configuration (which is the default) if
7481** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire
7482** statement is rolled back as if [ON CONFLICT | OR ABORT] had been
7483** specified as part of the users SQL statement, regardless of the actual
7484** ON CONFLICT mode specified.
7485**
7486** If X is non-zero, then the virtual table implementation guarantees
7487** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before
7488** any modifications to internal or persistent data structures have been made.
7489** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
7490** is able to roll back a statement or database transaction, and abandon
7491** or continue processing the current SQL statement as appropriate.
7492** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
7493** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
7494** had been ABORT.
7495**
7496** Virtual table implementations that are required to handle OR REPLACE
7497** must do so within the [xUpdate] method. If a call to the
7498** [sqlite3_vtab_on_conflict()] function indicates that the current ON
7499** CONFLICT policy is REPLACE, the virtual table implementation should
7500** silently replace the appropriate rows within the xUpdate callback and
7501** return SQLITE_OK. Or, if this is not possible, it may return
7502** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT
7503** constraint handling.
7504** </dl>
7505*/
7506#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1
7507
7508/*
7509** CAPI3REF: Determine The Virtual Table Conflict Policy
7510**
7511** This function may only be called from within a call to the [xUpdate] method
7512** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The
7513** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL],
7514** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
7515** of the SQL statement that triggered the call to the [xUpdate] method of the
7516** [virtual table].
7517*/
7518SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
7519
7520/*
7521** CAPI3REF: Conflict resolution modes
7522** KEYWORDS: {conflict resolution mode}
7523**
7524** These constants are returned by [sqlite3_vtab_on_conflict()] to
7525** inform a [virtual table] implementation what the [ON CONFLICT] mode
7526** is for the SQL statement being evaluated.
7527**
7528** Note that the [SQLITE_IGNORE] constant is also used as a potential
7529** return value from the [sqlite3_set_authorizer()] callback and that
7530** [SQLITE_ABORT] is also a [result code].
7531*/
7532#define SQLITE_ROLLBACK 1
7533/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */
7534#define SQLITE_FAIL     3
7535/* #define SQLITE_ABORT 4  // Also an error code */
7536#define SQLITE_REPLACE  5
7537
7538
7539
7540/*
7541** Undo the hack that converts floating point types to integer for
7542** builds on processors without floating point support.
7543*/
7544#ifdef SQLITE_OMIT_FLOATING_POINT
7545# undef double
7546#endif
7547
7548#if 0
7549}  /* End of the 'extern "C"' block */
7550#endif
7551#endif /* _SQLITE3_H_ */
7552
7553/*
7554** 2010 August 30
7555**
7556** The author disclaims copyright to this source code.  In place of
7557** a legal notice, here is a blessing:
7558**
7559**    May you do good and not evil.
7560**    May you find forgiveness for yourself and forgive others.
7561**    May you share freely, never taking more than you give.
7562**
7563*************************************************************************
7564*/
7565
7566#ifndef _SQLITE3RTREE_H_
7567#define _SQLITE3RTREE_H_
7568
7569
7570#if 0
7571extern "C" {
7572#endif
7573
7574typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry;
7575typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info;
7576
7577/* The double-precision datatype used by RTree depends on the
7578** SQLITE_RTREE_INT_ONLY compile-time option.
7579*/
7580#ifdef SQLITE_RTREE_INT_ONLY
7581  typedef sqlite3_int64 sqlite3_rtree_dbl;
7582#else
7583  typedef double sqlite3_rtree_dbl;
7584#endif
7585
7586/*
7587** Register a geometry callback named zGeom that can be used as part of an
7588** R-Tree geometry query as follows:
7589**
7590**   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
7591*/
7592SQLITE_API int sqlite3_rtree_geometry_callback(
7593  sqlite3 *db,
7594  const char *zGeom,
7595  int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*),
7596  void *pContext
7597);
7598
7599
7600/*
7601** A pointer to a structure of the following type is passed as the first
7602** argument to callbacks registered using rtree_geometry_callback().
7603*/
7604struct sqlite3_rtree_geometry {
7605  void *pContext;                 /* Copy of pContext passed to s_r_g_c() */
7606  int nParam;                     /* Size of array aParam[] */
7607  sqlite3_rtree_dbl *aParam;      /* Parameters passed to SQL geom function */
7608  void *pUser;                    /* Callback implementation user data */
7609  void (*xDelUser)(void *);       /* Called by SQLite to clean up pUser */
7610};
7611
7612/*
7613** Register a 2nd-generation geometry callback named zScore that can be
7614** used as part of an R-Tree geometry query as follows:
7615**
7616**   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zQueryFunc(... params ...)
7617*/
7618SQLITE_API int sqlite3_rtree_query_callback(
7619  sqlite3 *db,
7620  const char *zQueryFunc,
7621  int (*xQueryFunc)(sqlite3_rtree_query_info*),
7622  void *pContext,
7623  void (*xDestructor)(void*)
7624);
7625
7626
7627/*
7628** A pointer to a structure of the following type is passed as the
7629** argument to scored geometry callback registered using
7630** sqlite3_rtree_query_callback().
7631**
7632** Note that the first 5 fields of this structure are identical to
7633** sqlite3_rtree_geometry.  This structure is a subclass of
7634** sqlite3_rtree_geometry.
7635*/
7636struct sqlite3_rtree_query_info {
7637  void *pContext;                   /* pContext from when function registered */
7638  int nParam;                       /* Number of function parameters */
7639  sqlite3_rtree_dbl *aParam;        /* value of function parameters */
7640  void *pUser;                      /* callback can use this, if desired */
7641  void (*xDelUser)(void*);          /* function to free pUser */
7642  sqlite3_rtree_dbl *aCoord;        /* Coordinates of node or entry to check */
7643  unsigned int *anQueue;            /* Number of pending entries in the queue */
7644  int nCoord;                       /* Number of coordinates */
7645  int iLevel;                       /* Level of current node or entry */
7646  int mxLevel;                      /* The largest iLevel value in the tree */
7647  sqlite3_int64 iRowid;             /* Rowid for current entry */
7648  sqlite3_rtree_dbl rParentScore;   /* Score of parent node */
7649  int eParentWithin;                /* Visibility of parent node */
7650  int eWithin;                      /* OUT: Visiblity */
7651  sqlite3_rtree_dbl rScore;         /* OUT: Write the score here */
7652};
7653
7654/*
7655** Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin.
7656*/
7657#define NOT_WITHIN       0   /* Object completely outside of query region */
7658#define PARTLY_WITHIN    1   /* Object partially overlaps query region */
7659#define FULLY_WITHIN     2   /* Object fully contained within query region */
7660
7661
7662#if 0
7663}  /* end of the 'extern "C"' block */
7664#endif
7665
7666#endif  /* ifndef _SQLITE3RTREE_H_ */
7667
7668
7669/************** End of sqlite3.h *********************************************/
7670/************** Continuing where we left off in sqliteInt.h ******************/
7671
7672/*
7673** Include the configuration header output by 'configure' if we're using the
7674** autoconf-based build
7675*/
7676#ifdef _HAVE_SQLITE_CONFIG_H
7677#include "config.h"
7678#endif
7679
7680/************** Include sqliteLimit.h in the mid