4
** The author disclaims copyright to this source code. In place of
5
** a legal notice, here is a blessing:
7
** May you do good and not evil.
8
** May you find forgiveness for yourself and forgive others.
9
** May you share freely, never taking more than you give.
11
*************************************************************************
12
** This header file defines the interface that the SQLite library
13
** presents to client programs.
15
** @(#) $Id: sqlite.h.in,v 1.131 2005/03/21 04:04:03 danielk1977 Exp $
19
#include <stdarg.h> /* Needed for the definition of va_list */
22
** Make sure we can call this stuff from C++.
29
** The version of the SQLite library.
32
# undef SQLITE_VERSION
34
#define SQLITE_VERSION "3.2.1"
37
** The format of the version string is "X.Y.Z<trailing string>", where
38
** X is the major version number, Y is the minor version number and Z
39
** is the release number. The trailing string is often "alpha" or "beta".
40
** For example "3.1.1beta".
42
** The SQLITE_VERSION_NUMBER is an integer with the value
43
** (X*100000 + Y*1000 + Z). For example, for version "3.1.1beta",
44
** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using
45
** version 3.1.1 or greater at compile time, programs may use the test
46
** (SQLITE_VERSION_NUMBER>=3001001).
48
#ifdef SQLITE_VERSION_NUMBER
49
# undef SQLITE_VERSION_NUMBER
51
#define SQLITE_VERSION_NUMBER 3002001
54
** The version string is also compiled into the library so that a program
55
** can check to make sure that the lib*.a file and the *.h file are from
56
** the same version. The sqlite3_libversion() function returns a pointer
57
** to the sqlite3_version variable - useful in DLLs which cannot access
60
extern const char sqlite3_version[];
61
const char *sqlite3_libversion(void);
64
** Return the value of the SQLITE_VERSION_NUMBER macro when the
65
** library was compiled.
67
int sqlite3_libversion_number(void);
70
** Each open sqlite database is represented by an instance of the
71
** following opaque structure.
73
typedef struct sqlite3 sqlite3;
77
** Some compilers do not support the "long long" datatype. So we have
78
** to do a typedef that for 64-bit integers that depends on what compiler
81
#if defined(_MSC_VER) || defined(__BORLANDC__)
82
typedef __int64 sqlite_int64;
83
typedef unsigned __int64 sqlite_uint64;
85
typedef long long int sqlite_int64;
86
typedef unsigned long long int sqlite_uint64;
91
** A function to close the database.
93
** Call this function with a pointer to a structure that was previously
94
** returned from sqlite3_open() and the corresponding database will by closed.
96
** All SQL statements prepared using sqlite3_prepare() or
97
** sqlite3_prepare16() must be deallocated using sqlite3_finalize() before
98
** this routine is called. Otherwise, SQLITE_BUSY is returned and the
99
** database connection remains open.
101
int sqlite3_close(sqlite3 *);
104
** The type for a callback function.
106
typedef int (*sqlite3_callback)(void*,int,char**, char**);
109
** A function to executes one or more statements of SQL.
111
** If one or more of the SQL statements are queries, then
112
** the callback function specified by the 3rd parameter is
113
** invoked once for each row of the query result. This callback
114
** should normally return 0. If the callback returns a non-zero
115
** value then the query is aborted, all subsequent SQL statements
116
** are skipped and the sqlite3_exec() function returns the SQLITE_ABORT.
118
** The 4th parameter is an arbitrary pointer that is passed
119
** to the callback function as its first parameter.
121
** The 2nd parameter to the callback function is the number of
122
** columns in the query result. The 3rd parameter to the callback
123
** is an array of strings holding the values for each column.
124
** The 4th parameter to the callback is an array of strings holding
125
** the names of each column.
127
** The callback function may be NULL, even for queries. A NULL
128
** callback is not an error. It just means that no callback
131
** If an error occurs while parsing or evaluating the SQL (but
132
** not while executing the callback) then an appropriate error
133
** message is written into memory obtained from malloc() and
134
** *errmsg is made to point to that message. The calling function
135
** is responsible for freeing the memory that holds the error
136
** message. Use sqlite3_free() for this. If errmsg==NULL,
137
** then no error message is ever written.
139
** The return value is is SQLITE_OK if there are no errors and
140
** some other return code if there is an error. The particular
141
** return value depends on the type of error.
143
** If the query could not be executed because a database file is
144
** locked or busy, then this function returns SQLITE_BUSY. (This
145
** behavior can be modified somewhat using the sqlite3_busy_handler()
146
** and sqlite3_busy_timeout() functions below.)
149
sqlite3*, /* An open database */
150
const char *sql, /* SQL to be executed */
151
sqlite3_callback, /* Callback function */
152
void *, /* 1st argument to callback function */
153
char **errmsg /* Error msg written here */
157
** Return values for sqlite3_exec() and sqlite3_step()
159
#define SQLITE_OK 0 /* Successful result */
160
#define SQLITE_ERROR 1 /* SQL error or missing database */
161
#define SQLITE_INTERNAL 2 /* An internal logic error in SQLite */
162
#define SQLITE_PERM 3 /* Access permission denied */
163
#define SQLITE_ABORT 4 /* Callback routine requested an abort */
164
#define SQLITE_BUSY 5 /* The database file is locked */
165
#define SQLITE_LOCKED 6 /* A table in the database is locked */
166
#define SQLITE_NOMEM 7 /* A malloc() failed */
167
#define SQLITE_READONLY 8 /* Attempt to write a readonly database */
168
#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/
169
#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */
170
#define SQLITE_CORRUPT 11 /* The database disk image is malformed */
171
#define SQLITE_NOTFOUND 12 /* (Internal Only) Table or record not found */
172
#define SQLITE_FULL 13 /* Insertion failed because database is full */
173
#define SQLITE_CANTOPEN 14 /* Unable to open the database file */
174
#define SQLITE_PROTOCOL 15 /* Database lock protocol error */
175
#define SQLITE_EMPTY 16 /* Database is empty */
176
#define SQLITE_SCHEMA 17 /* The database schema changed */
177
#define SQLITE_TOOBIG 18 /* Too much data for one row of a table */
178
#define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation */
179
#define SQLITE_MISMATCH 20 /* Data type mismatch */
180
#define SQLITE_MISUSE 21 /* Library used incorrectly */
181
#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
182
#define SQLITE_AUTH 23 /* Authorization denied */
183
#define SQLITE_FORMAT 24 /* Auxiliary database format error */
184
#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
185
#define SQLITE_NOTADB 26 /* File opened that is not a database file */
186
#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */
187
#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */
190
** Each entry in an SQLite table has a unique integer key. (The key is
191
** the value of the INTEGER PRIMARY KEY column if there is such a column,
192
** otherwise the key is generated at random. The unique key is always
193
** available as the ROWID, OID, or _ROWID_ column.) The following routine
194
** returns the integer key of the most recent insert in the database.
196
** This function is similar to the mysql_insert_id() function from MySQL.
198
sqlite_int64 sqlite3_last_insert_rowid(sqlite3*);
201
** This function returns the number of database rows that were changed
202
** (or inserted or deleted) by the most recent called sqlite3_exec().
204
** All changes are counted, even if they were later undone by a
205
** ROLLBACK or ABORT. Except, changes associated with creating and
206
** dropping tables are not counted.
208
** If a callback invokes sqlite3_exec() recursively, then the changes
209
** in the inner, recursive call are counted together with the changes
210
** in the outer call.
212
** SQLite implements the command "DELETE FROM table" without a WHERE clause
213
** by dropping and recreating the table. (This is much faster than going
214
** through and deleting individual elements form the table.) Because of
215
** this optimization, the change count for "DELETE FROM table" will be
216
** zero regardless of the number of elements that were originally in the
217
** table. To get an accurate count of the number of rows deleted, use
218
** "DELETE FROM table WHERE 1" instead.
220
int sqlite3_changes(sqlite3*);
223
** This function returns the number of database rows that have been
224
** modified by INSERT, UPDATE or DELETE statements since the database handle
225
** was opened. This includes UPDATE, INSERT and DELETE statements executed
226
** as part of trigger programs. All changes are counted as soon as the
227
** statement that makes them is completed (when the statement handle is
228
** passed to sqlite3_reset() or sqlite_finalise()).
230
** SQLite implements the command "DELETE FROM table" without a WHERE clause
231
** by dropping and recreating the table. (This is much faster than going
232
** through and deleting individual elements form the table.) Because of
233
** this optimization, the change count for "DELETE FROM table" will be
234
** zero regardless of the number of elements that were originally in the
235
** table. To get an accurate count of the number of rows deleted, use
236
** "DELETE FROM table WHERE 1" instead.
238
int sqlite3_total_changes(sqlite3*);
240
/* This function causes any pending database operation to abort and
241
** return at its earliest opportunity. This routine is typically
242
** called in response to a user action such as pressing "Cancel"
243
** or Ctrl-C where the user wants a long query operation to halt
246
void sqlite3_interrupt(sqlite3*);
249
/* These functions return true if the given input string comprises
250
** one or more complete SQL statements. For the sqlite3_complete() call,
251
** the parameter must be a nul-terminated UTF-8 string. For
252
** sqlite3_complete16(), a nul-terminated machine byte order UTF-16 string
255
** The algorithm is simple. If the last token other than spaces
256
** and comments is a semicolon, then return true. otherwise return
259
int sqlite3_complete(const char *sql);
260
int sqlite3_complete16(const void *sql);
263
** This routine identifies a callback function that is invoked
264
** whenever an attempt is made to open a database table that is
265
** currently locked by another process or thread. If the busy callback
266
** is NULL, then sqlite3_exec() returns SQLITE_BUSY immediately if
267
** it finds a locked table. If the busy callback is not NULL, then
268
** sqlite3_exec() invokes the callback with three arguments. The
269
** second argument is the name of the locked table and the third
270
** argument is the number of times the table has been busy. If the
271
** busy callback returns 0, then sqlite3_exec() immediately returns
272
** SQLITE_BUSY. If the callback returns non-zero, then sqlite3_exec()
273
** tries to open the table again and the cycle repeats.
275
** The default busy callback is NULL.
277
** Sqlite is re-entrant, so the busy handler may start a new query.
278
** (It is not clear why anyone would every want to do this, but it
279
** is allowed, in theory.) But the busy handler may not close the
280
** database. Closing the database from a busy handler will delete
281
** data structures out from under the executing query and will
282
** probably result in a coredump.
284
int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
287
** This routine sets a busy handler that sleeps for a while when a
288
** table is locked. The handler will sleep multiple times until
289
** at least "ms" milleseconds of sleeping have been done. After
290
** "ms" milleseconds of sleeping, the handler returns 0 which
291
** causes sqlite3_exec() to return SQLITE_BUSY.
293
** Calling this routine with an argument less than or equal to zero
294
** turns off all busy handlers.
296
int sqlite3_busy_timeout(sqlite3*, int ms);
299
** This next routine is really just a wrapper around sqlite3_exec().
300
** Instead of invoking a user-supplied callback for each row of the
301
** result, this routine remembers each row of the result in memory
302
** obtained from malloc(), then returns all of the result after the
303
** query has finished.
305
** As an example, suppose the query result where this table:
308
** -----------------------
313
** If the 3rd argument were &azResult then after the function returns
314
** azResult will contain the following data:
316
** azResult[0] = "Name";
317
** azResult[1] = "Age";
318
** azResult[2] = "Alice";
319
** azResult[3] = "43";
320
** azResult[4] = "Bob";
321
** azResult[5] = "28";
322
** azResult[6] = "Cindy";
323
** azResult[7] = "21";
325
** Notice that there is an extra row of data containing the column
326
** headers. But the *nrow return value is still 3. *ncolumn is
327
** set to 2. In general, the number of values inserted into azResult
328
** will be ((*nrow) + 1)*(*ncolumn).
330
** After the calling function has finished using the result, it should
331
** pass the result data pointer to sqlite3_free_table() in order to
332
** release the memory that was malloc-ed. Because of the way the
333
** malloc() happens, the calling function must not try to call
334
** free() directly. Only sqlite3_free_table() is able to release
335
** the memory properly and safely.
337
** The return value of this routine is the same as from sqlite3_exec().
339
int sqlite3_get_table(
340
sqlite3*, /* An open database */
341
const char *sql, /* SQL to be executed */
342
char ***resultp, /* Result written to a char *[] that this points to */
343
int *nrow, /* Number of result rows written here */
344
int *ncolumn, /* Number of result columns written here */
345
char **errmsg /* Error msg written here */
349
** Call this routine to free the memory that sqlite3_get_table() allocated.
351
void sqlite3_free_table(char **result);
354
** The following routines are variants of the "sprintf()" from the
355
** standard C library. The resulting string is written into memory
356
** obtained from malloc() so that there is never a possiblity of buffer
357
** overflow. These routines also implement some additional formatting
358
** options that are useful for constructing SQL statements.
360
** The strings returned by these routines should be freed by calling
363
** All of the usual printf formatting options apply. In addition, there
364
** is a "%q" option. %q works like %s in that it substitutes a null-terminated
365
** string from the argument list. But %q also doubles every '\'' character.
366
** %q is designed for use inside a string literal. By doubling each '\''
367
** character it escapes that character and allows it to be inserted into
370
** For example, so some string variable contains text as follows:
372
** char *zText = "It's a happy day!";
374
** We can use this text in an SQL statement as follows:
376
** sqlite3_exec_printf(db, "INSERT INTO table VALUES('%q')",
377
** callback1, 0, 0, zText);
379
** Because the %q format string is used, the '\'' character in zText
380
** is escaped and the SQL generated is as follows:
382
** INSERT INTO table1 VALUES('It''s a happy day!')
384
** This is correct. Had we used %s instead of %q, the generated SQL
385
** would have looked like this:
387
** INSERT INTO table1 VALUES('It's a happy day!');
389
** This second example is an SQL syntax error. As a general rule you
390
** should always use %q instead of %s when inserting text into a string
393
char *sqlite3_mprintf(const char*,...);
394
char *sqlite3_vmprintf(const char*, va_list);
395
void sqlite3_free(char *z);
396
char *sqlite3_snprintf(int,char*,const char*, ...);
398
#ifndef SQLITE_OMIT_AUTHORIZATION
400
** This routine registers a callback with the SQLite library. The
401
** callback is invoked (at compile-time, not at run-time) for each
402
** attempt to access a column of a table in the database. The callback
403
** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire
404
** SQL statement should be aborted with an error and SQLITE_IGNORE
405
** if the column should be treated as a NULL value.
407
int sqlite3_set_authorizer(
409
int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
415
** The second parameter to the access authorization function above will
416
** be one of the values below. These values signify what kind of operation
417
** is to be authorized. The 3rd and 4th parameters to the authorization
418
** function will be parameters or NULL depending on which of the following
419
** codes is used as the second parameter. The 5th parameter is the name
420
** of the database ("main", "temp", etc.) if applicable. The 6th parameter
421
** is the name of the inner-most trigger or view that is responsible for
422
** the access attempt or NULL if this access attempt is directly from
427
#define SQLITE_COPY 0 /* Table Name File Name */
428
#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */
429
#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */
430
#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */
431
#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */
432
#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */
433
#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */
434
#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */
435
#define SQLITE_CREATE_VIEW 8 /* View Name NULL */
436
#define SQLITE_DELETE 9 /* Table Name NULL */
437
#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */
438
#define SQLITE_DROP_TABLE 11 /* Table Name NULL */
439
#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */
440
#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */
441
#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */
442
#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */
443
#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */
444
#define SQLITE_DROP_VIEW 17 /* View Name NULL */
445
#define SQLITE_INSERT 18 /* Table Name NULL */
446
#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */
447
#define SQLITE_READ 20 /* Table Name Column Name */
448
#define SQLITE_SELECT 21 /* NULL NULL */
449
#define SQLITE_TRANSACTION 22 /* NULL NULL */
450
#define SQLITE_UPDATE 23 /* Table Name Column Name */
451
#define SQLITE_ATTACH 24 /* Filename NULL */
452
#define SQLITE_DETACH 25 /* Database Name NULL */
453
#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
454
#define SQLITE_REINDEX 27 /* Index Name NULL */
458
** The return value of the authorization function should be one of the
459
** following constants:
461
/* #define SQLITE_OK 0 // Allow access (This is actually defined above) */
462
#define SQLITE_DENY 1 /* Abort the SQL statement with an error */
463
#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */
466
** Register a function that is called at every invocation of sqlite3_exec()
467
** or sqlite3_prepare(). This function can be used (for example) to generate
468
** a log file of all SQL executed against a database.
470
void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
473
** This routine configures a callback function - the progress callback - that
474
** is invoked periodically during long running calls to sqlite3_exec(),
475
** sqlite3_step() and sqlite3_get_table(). An example use for this API is to
476
** keep a GUI updated during a large query.
478
** The progress callback is invoked once for every N virtual machine opcodes,
479
** where N is the second argument to this function. The progress callback
480
** itself is identified by the third argument to this function. The fourth
481
** argument to this function is a void pointer passed to the progress callback
482
** function each time it is invoked.
484
** If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results
485
** in less than N opcodes being executed, then the progress callback is not
488
** To remove the progress callback altogether, pass NULL as the third
489
** argument to this function.
491
** If the progress callback returns a result other than 0, then the current
492
** query is immediately terminated and any database changes rolled back. If the
493
** query was part of a larger transaction, then the transaction is not rolled
494
** back and remains active. The sqlite3_exec() call returns SQLITE_ABORT.
496
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
498
void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
501
** Register a callback function to be invoked whenever a new transaction
502
** is committed. The pArg argument is passed through to the callback.
503
** callback. If the callback function returns non-zero, then the commit
504
** is converted into a rollback.
506
** If another function was previously registered, its pArg value is returned.
507
** Otherwise NULL is returned.
509
** Registering a NULL function disables the callback.
511
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
513
void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
516
** Open the sqlite database file "filename". The "filename" is UTF-8
517
** encoded for sqlite3_open() and UTF-16 encoded in the native byte order
518
** for sqlite3_open16(). An sqlite3* handle is returned in *ppDb, even
519
** if an error occurs. If the database is opened (or created) successfully,
520
** then SQLITE_OK is returned. Otherwise an error code is returned. The
521
** sqlite3_errmsg() or sqlite3_errmsg16() routines can be used to obtain
522
** an English language description of the error.
524
** If the database file does not exist, then a new database is created.
525
** The encoding for the database is UTF-8 if sqlite3_open() is called and
526
** UTF-16 if sqlite3_open16 is used.
528
** Whether or not an error occurs when it is opened, resources associated
529
** with the sqlite3* handle should be released by passing it to
530
** sqlite3_close() when it is no longer required.
533
const char *filename, /* Database filename (UTF-8) */
534
sqlite3 **ppDb /* OUT: SQLite db handle */
537
const void *filename, /* Database filename (UTF-16) */
538
sqlite3 **ppDb /* OUT: SQLite db handle */
542
** Return the error code for the most recent sqlite3_* API call associated
543
** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent
544
** API call was successful.
546
** Calls to many sqlite3_* functions set the error code and string returned
547
** by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16()
548
** (overwriting the previous values). Note that calls to sqlite3_errcode(),
549
** sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the
550
** results of future invocations.
552
** Assuming no other intervening sqlite3_* API calls are made, the error
553
** code returned by this function is associated with the same error as
554
** the strings returned by sqlite3_errmsg() and sqlite3_errmsg16().
556
int sqlite3_errcode(sqlite3 *db);
559
** Return a pointer to a UTF-8 encoded string describing in english the
560
** error condition for the most recent sqlite3_* API call. The returned
561
** string is always terminated by an 0x00 byte.
563
** The string "not an error" is returned when the most recent API call was
566
const char *sqlite3_errmsg(sqlite3*);
569
** Return a pointer to a UTF-16 native byte order encoded string describing
570
** in english the error condition for the most recent sqlite3_* API call.
571
** The returned string is always terminated by a pair of 0x00 bytes.
573
** The string "not an error" is returned when the most recent API call was
576
const void *sqlite3_errmsg16(sqlite3*);
579
** An instance of the following opaque structure is used to represent
580
** a compiled SQL statment.
582
typedef struct sqlite3_stmt sqlite3_stmt;
585
** To execute an SQL query, it must first be compiled into a byte-code
586
** program using one of the following routines. The only difference between
587
** them is that the second argument, specifying the SQL statement to
588
** compile, is assumed to be encoded in UTF-8 for the sqlite3_prepare()
589
** function and UTF-16 for sqlite3_prepare16().
591
** The first parameter "db" is an SQLite database handle. The second
592
** parameter "zSql" is the statement to be compiled, encoded as either
593
** UTF-8 or UTF-16 (see above). If the next parameter, "nBytes", is less
594
** than zero, then zSql is read up to the first nul terminator. If
595
** "nBytes" is not less than zero, then it is the length of the string zSql
596
** in bytes (not characters).
598
** *pzTail is made to point to the first byte past the end of the first
599
** SQL statement in zSql. This routine only compiles the first statement
600
** in zSql, so *pzTail is left pointing to what remains uncompiled.
602
** *ppStmt is left pointing to a compiled SQL statement that can be
603
** executed using sqlite3_step(). Or if there is an error, *ppStmt may be
604
** set to NULL. If the input text contained no SQL (if the input is and
605
** empty string or a comment) then *ppStmt is set to NULL.
607
** On success, SQLITE_OK is returned. Otherwise an error code is returned.
610
sqlite3 *db, /* Database handle */
611
const char *zSql, /* SQL statement, UTF-8 encoded */
612
int nBytes, /* Length of zSql in bytes. */
613
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
614
const char **pzTail /* OUT: Pointer to unused portion of zSql */
616
int sqlite3_prepare16(
617
sqlite3 *db, /* Database handle */
618
const void *zSql, /* SQL statement, UTF-16 encoded */
619
int nBytes, /* Length of zSql in bytes. */
620
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
621
const void **pzTail /* OUT: Pointer to unused portion of zSql */
625
** Pointers to the following two opaque structures are used to communicate
626
** with the implementations of user-defined functions.
628
typedef struct sqlite3_context sqlite3_context;
629
typedef struct Mem sqlite3_value;
632
** In the SQL strings input to sqlite3_prepare() and sqlite3_prepare16(),
633
** one or more literals can be replace by parameters "?" or ":AAA" or
634
** "$VVV" where AAA is an identifer and VVV is a variable name according
635
** to the syntax rules of the TCL programming language.
636
** The value of these parameters (also called "host parameter names") can
637
** be set using the routines listed below.
639
** In every case, the first parameter is a pointer to the sqlite3_stmt
640
** structure returned from sqlite3_prepare(). The second parameter is the
641
** index of the parameter. The first parameter as an index of 1. For
642
** named parameters (":AAA" or "$VVV") you can use
643
** sqlite3_bind_parameter_index() to get the correct index value given
644
** the parameters name. If the same named parameter occurs more than
645
** once, it is assigned the same index each time.
647
** The fifth parameter to sqlite3_bind_blob(), sqlite3_bind_text(), and
648
** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
649
** text after SQLite has finished with it. If the fifth argument is the
650
** special value SQLITE_STATIC, then the library assumes that the information
651
** is in static, unmanaged space and does not need to be freed. If the
652
** fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its
653
** own private copy of the data.
655
** The sqlite3_bind_* routine must be called before sqlite3_step() after
656
** an sqlite3_prepare() or sqlite3_reset(). Unbound parameterss are
657
** interpreted as NULL.
659
int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
660
int sqlite3_bind_double(sqlite3_stmt*, int, double);
661
int sqlite3_bind_int(sqlite3_stmt*, int, int);
662
int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite_int64);
663
int sqlite3_bind_null(sqlite3_stmt*, int);
664
int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
665
int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
666
int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
669
** Return the number of parameters in a compiled SQL statement. This
670
** routine was added to support DBD::SQLite.
672
int sqlite3_bind_parameter_count(sqlite3_stmt*);
675
** Return the name of the i-th parameter. Ordinary parameters "?" are
676
** nameless and a NULL is returned. For parameters of the form :AAA or
677
** $VVV the complete text of the parameter name is returned, including
678
** the initial ":" or "$". NULL is returned if the index is out of range.
680
const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
683
** Return the index of a parameter with the given name. The name
684
** must match exactly. If no parameter with the given name is found,
687
int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
690
** Set all the parameters in the compiled SQL statement to NULL.
692
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
694
int sqlite3_clear_bindings(sqlite3_stmt*);
697
** Return the number of columns in the result set returned by the compiled
698
** SQL statement. This routine returns 0 if pStmt is an SQL statement
699
** that does not return data (for example an UPDATE).
701
int sqlite3_column_count(sqlite3_stmt *pStmt);
704
** The first parameter is a compiled SQL statement. This function returns
705
** the column heading for the Nth column of that statement, where N is the
706
** second function parameter. The string returned is UTF-8 for
707
** sqlite3_column_name() and UTF-16 for sqlite3_column_name16().
709
const char *sqlite3_column_name(sqlite3_stmt*,int);
710
const void *sqlite3_column_name16(sqlite3_stmt*,int);
713
** The first parameter is a compiled SQL statement. If this statement
714
** is a SELECT statement, the Nth column of the returned result set
715
** of the SELECT is a table column then the declared type of the table
716
** column is returned. If the Nth column of the result set is not at table
717
** column, then a NULL pointer is returned. The returned string is always
718
** UTF-8 encoded. For example, in the database schema:
720
** CREATE TABLE t1(c1 VARIANT);
722
** And the following statement compiled:
724
** SELECT c1 + 1, 0 FROM t1;
726
** Then this routine would return the string "VARIANT" for the second
727
** result column (i==1), and a NULL pointer for the first result column
730
const char *sqlite3_column_decltype(sqlite3_stmt *, int i);
733
** The first parameter is a compiled SQL statement. If this statement
734
** is a SELECT statement, the Nth column of the returned result set
735
** of the SELECT is a table column then the declared type of the table
736
** column is returned. If the Nth column of the result set is not at table
737
** column, then a NULL pointer is returned. The returned string is always
738
** UTF-16 encoded. For example, in the database schema:
740
** CREATE TABLE t1(c1 INTEGER);
742
** And the following statement compiled:
744
** SELECT c1 + 1, 0 FROM t1;
746
** Then this routine would return the string "INTEGER" for the second
747
** result column (i==1), and a NULL pointer for the first result column
750
const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
753
** After an SQL query has been compiled with a call to either
754
** sqlite3_prepare() or sqlite3_prepare16(), then this function must be
755
** called one or more times to execute the statement.
757
** The return value will be either SQLITE_BUSY, SQLITE_DONE,
758
** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE.
760
** SQLITE_BUSY means that the database engine attempted to open
761
** a locked database and there is no busy callback registered.
762
** Call sqlite3_step() again to retry the open.
764
** SQLITE_DONE means that the statement has finished executing
765
** successfully. sqlite3_step() should not be called again on this virtual
768
** If the SQL statement being executed returns any data, then
769
** SQLITE_ROW is returned each time a new row of data is ready
770
** for processing by the caller. The values may be accessed using
771
** the sqlite3_column_*() functions described below. sqlite3_step()
772
** is called again to retrieve the next row of data.
774
** SQLITE_ERROR means that a run-time error (such as a constraint
775
** violation) has occurred. sqlite3_step() should not be called again on
776
** the VM. More information may be found by calling sqlite3_errmsg().
778
** SQLITE_MISUSE means that the this routine was called inappropriately.
779
** Perhaps it was called on a virtual machine that had already been
780
** finalized or on one that had previously returned SQLITE_ERROR or
781
** SQLITE_DONE. Or it could be the case the the same database connection
782
** is being used simulataneously by two or more threads.
784
int sqlite3_step(sqlite3_stmt*);
787
** Return the number of values in the current row of the result set.
789
** After a call to sqlite3_step() that returns SQLITE_ROW, this routine
790
** will return the same value as the sqlite3_column_count() function.
791
** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or
792
** error code, or before sqlite3_step() has been called on a
793
** compiled SQL statement, this routine returns zero.
795
int sqlite3_data_count(sqlite3_stmt *pStmt);
798
** Values are stored in the database in one of the following fundamental
801
#define SQLITE_INTEGER 1
802
#define SQLITE_FLOAT 2
803
/* #define SQLITE_TEXT 3 // See below */
804
#define SQLITE_BLOB 4
805
#define SQLITE_NULL 5
808
** SQLite version 2 defines SQLITE_TEXT differently. To allow both
809
** version 2 and version 3 to be included, undefine them both if a
810
** conflict is seen. Define SQLITE3_TEXT to be the version 3 value.
815
# define SQLITE_TEXT 3
817
#define SQLITE3_TEXT 3
820
** The next group of routines returns information about the information
821
** in a single column of the current result row of a query. In every
822
** case the first parameter is a pointer to the SQL statement that is being
823
** executed (the sqlite_stmt* that was returned from sqlite3_prepare()) and
824
** the second argument is the index of the column for which information
825
** should be returned. iCol is zero-indexed. The left-most column as an
828
** If the SQL statement is not currently point to a valid row, or if the
829
** the colulmn index is out of range, the result is undefined.
831
** These routines attempt to convert the value where appropriate. For
832
** example, if the internal representation is FLOAT and a text result
833
** is requested, sprintf() is used internally to do the conversion
834
** automatically. The following table details the conversions that
837
** Internal Type Requested Type Conversion
838
** ------------- -------------- --------------------------
839
** NULL INTEGER Result is 0
840
** NULL FLOAT Result is 0.0
841
** NULL TEXT Result is an empty string
842
** NULL BLOB Result is a zero-length BLOB
843
** INTEGER FLOAT Convert from integer to float
844
** INTEGER TEXT ASCII rendering of the integer
845
** INTEGER BLOB Same as for INTEGER->TEXT
846
** FLOAT INTEGER Convert from float to integer
847
** FLOAT TEXT ASCII rendering of the float
848
** FLOAT BLOB Same as FLOAT->TEXT
849
** TEXT INTEGER Use atoi()
850
** TEXT FLOAT Use atof()
851
** TEXT BLOB No change
852
** BLOB INTEGER Convert to TEXT then use atoi()
853
** BLOB FLOAT Convert to TEXT then use atof()
854
** BLOB TEXT Add a \000 terminator if needed
856
** The following access routines are provided:
858
** _type() Return the datatype of the result. This is one of
859
** SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB,
861
** _blob() Return the value of a BLOB.
862
** _bytes() Return the number of bytes in a BLOB value or the number
863
** of bytes in a TEXT value represented as UTF-8. The \000
864
** terminator is included in the byte count for TEXT values.
865
** _bytes16() Return the number of bytes in a BLOB value or the number
866
** of bytes in a TEXT value represented as UTF-16. The \u0000
867
** terminator is included in the byte count for TEXT values.
868
** _double() Return a FLOAT value.
869
** _int() Return an INTEGER value in the host computer's native
870
** integer representation. This might be either a 32- or 64-bit
871
** integer depending on the host.
872
** _int64() Return an INTEGER value as a 64-bit signed integer.
873
** _text() Return the value as UTF-8 text.
874
** _text16() Return the value as UTF-16 text.
876
const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
877
int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
878
int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
879
double sqlite3_column_double(sqlite3_stmt*, int iCol);
880
int sqlite3_column_int(sqlite3_stmt*, int iCol);
881
sqlite_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
882
const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
883
const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
884
int sqlite3_column_type(sqlite3_stmt*, int iCol);
887
** The sqlite3_finalize() function is called to delete a compiled
888
** SQL statement obtained by a previous call to sqlite3_prepare()
889
** or sqlite3_prepare16(). If the statement was executed successfully, or
890
** not executed at all, then SQLITE_OK is returned. If execution of the
891
** statement failed then an error code is returned.
893
** This routine can be called at any point during the execution of the
894
** virtual machine. If the virtual machine has not completed execution
895
** when this routine is called, that is like encountering an error or
896
** an interrupt. (See sqlite3_interrupt().) Incomplete updates may be
897
** rolled back and transactions cancelled, depending on the circumstances,
898
** and the result code returned will be SQLITE_ABORT.
900
int sqlite3_finalize(sqlite3_stmt *pStmt);
903
** The sqlite3_reset() function is called to reset a compiled SQL
904
** statement obtained by a previous call to sqlite3_prepare() or
905
** sqlite3_prepare16() back to it's initial state, ready to be re-executed.
906
** Any SQL statement variables that had values bound to them using
907
** the sqlite3_bind_*() API retain their values.
909
int sqlite3_reset(sqlite3_stmt *pStmt);
912
** The following two functions are used to add user functions or aggregates
913
** implemented in C to the SQL langauge interpreted by SQLite. The
914
** difference only between the two is that the second parameter, the
915
** name of the (scalar) function or aggregate, is encoded in UTF-8 for
916
** sqlite3_create_function() and UTF-16 for sqlite3_create_function16().
918
** The first argument is the database handle that the new function or
919
** aggregate is to be added to. If a single program uses more than one
920
** database handle internally, then user functions or aggregates must
921
** be added individually to each database handle with which they will be
924
** The third parameter is the number of arguments that the function or
925
** aggregate takes. If this parameter is negative, then the function or
926
** aggregate may take any number of arguments.
928
** The fourth parameter is one of SQLITE_UTF* values defined below,
929
** indicating the encoding that the function is most likely to handle
930
** values in. This does not change the behaviour of the programming
931
** interface. However, if two versions of the same function are registered
932
** with different encoding values, SQLite invokes the version likely to
933
** minimize conversions between text encodings.
935
** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are
936
** pointers to user implemented C functions that implement the user
937
** function or aggregate. A scalar function requires an implementation of
938
** the xFunc callback only, NULL pointers should be passed as the xStep
939
** and xFinal parameters. An aggregate function requires an implementation
940
** of xStep and xFinal, but NULL should be passed for xFunc. To delete an
941
** existing user function or aggregate, pass NULL for all three function
942
** callback. Specifying an inconstent set of callback values, such as an
943
** xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is
946
int sqlite3_create_function(
948
const char *zFunctionName,
952
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
953
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
954
void (*xFinal)(sqlite3_context*)
956
int sqlite3_create_function16(
958
const void *zFunctionName,
962
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
963
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
964
void (*xFinal)(sqlite3_context*)
968
** The next routine returns the number of calls to xStep for a particular
969
** aggregate function instance. The current call to xStep counts so this
970
** routine always returns at least 1.
972
int sqlite3_aggregate_count(sqlite3_context*);
975
** The next group of routines returns information about parameters to
976
** a user-defined function. Function implementations use these routines
977
** to access their parameters. These routines are the same as the
978
** sqlite3_column_* routines except that these routines take a single
979
** sqlite3_value* pointer instead of an sqlite3_stmt* and an integer
982
const void *sqlite3_value_blob(sqlite3_value*);
983
int sqlite3_value_bytes(sqlite3_value*);
984
int sqlite3_value_bytes16(sqlite3_value*);
985
double sqlite3_value_double(sqlite3_value*);
986
int sqlite3_value_int(sqlite3_value*);
987
sqlite_int64 sqlite3_value_int64(sqlite3_value*);
988
const unsigned char *sqlite3_value_text(sqlite3_value*);
989
const void *sqlite3_value_text16(sqlite3_value*);
990
const void *sqlite3_value_text16le(sqlite3_value*);
991
const void *sqlite3_value_text16be(sqlite3_value*);
992
int sqlite3_value_type(sqlite3_value*);
995
** Aggregate functions use the following routine to allocate
996
** a structure for storing their state. The first time this routine
997
** is called for a particular aggregate, a new structure of size nBytes
998
** is allocated, zeroed, and returned. On subsequent calls (for the
999
** same aggregate instance) the same buffer is returned. The implementation
1000
** of the aggregate can use the returned buffer to accumulate data.
1002
** The buffer allocated is freed automatically by SQLite.
1004
void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
1007
** The pUserData parameter to the sqlite3_create_function() and
1008
** sqlite3_create_aggregate() routines used to register user functions
1009
** is available to the implementation of the function using this
1012
void *sqlite3_user_data(sqlite3_context*);
1015
** The following two functions may be used by scalar user functions to
1016
** associate meta-data with argument values. If the same value is passed to
1017
** multiple invocations of the user-function during query execution, under
1018
** some circumstances the associated meta-data may be preserved. This may
1019
** be used, for example, to add a regular-expression matching scalar
1020
** function. The compiled version of the regular expression is stored as
1021
** meta-data associated with the SQL value passed as the regular expression
1024
** Calling sqlite3_get_auxdata() returns a pointer to the meta data
1025
** associated with the Nth argument value to the current user function
1026
** call, where N is the second parameter. If no meta-data has been set for
1027
** that value, then a NULL pointer is returned.
1029
** The sqlite3_set_auxdata() is used to associate meta data with a user
1030
** function argument. The third parameter is a pointer to the meta data
1031
** to be associated with the Nth user function argument value. The fourth
1032
** parameter specifies a 'delete function' that will be called on the meta
1033
** data pointer to release it when it is no longer required. If the delete
1034
** function pointer is NULL, it is not invoked.
1036
** In practice, meta-data is preserved between function calls for
1037
** expressions that are constant at compile time. This includes literal
1038
** values and SQL variables.
1040
void *sqlite3_get_auxdata(sqlite3_context*, int);
1041
void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*));
1045
** These are special value for the destructor that is passed in as the
1046
** final argument to routines like sqlite3_result_blob(). If the destructor
1047
** argument is SQLITE_STATIC, it means that the content pointer is constant
1048
** and will never change. It does not need to be destroyed. The
1049
** SQLITE_TRANSIENT value means that the content will likely change in
1050
** the near future and that SQLite should make its own private copy of
1051
** the content before returning.
1053
#define SQLITE_STATIC ((void(*)(void *))0)
1054
#define SQLITE_TRANSIENT ((void(*)(void *))-1)
1057
** User-defined functions invoke the following routines in order to
1058
** set their return value.
1060
void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
1061
void sqlite3_result_double(sqlite3_context*, double);
1062
void sqlite3_result_error(sqlite3_context*, const char*, int);
1063
void sqlite3_result_error16(sqlite3_context*, const void*, int);
1064
void sqlite3_result_int(sqlite3_context*, int);
1065
void sqlite3_result_int64(sqlite3_context*, sqlite_int64);
1066
void sqlite3_result_null(sqlite3_context*);
1067
void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
1068
void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
1069
void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
1070
void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
1071
void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
1074
** These are the allowed values for the eTextRep argument to
1075
** sqlite3_create_collation and sqlite3_create_function.
1077
#define SQLITE_UTF8 1
1078
#define SQLITE_UTF16LE 2
1079
#define SQLITE_UTF16BE 3
1080
#define SQLITE_UTF16 4 /* Use native byte order */
1081
#define SQLITE_ANY 5 /* sqlite3_create_function only */
1084
** These two functions are used to add new collation sequences to the
1085
** sqlite3 handle specified as the first argument.
1087
** The name of the new collation sequence is specified as a UTF-8 string
1088
** for sqlite3_create_collation() and a UTF-16 string for
1089
** sqlite3_create_collation16(). In both cases the name is passed as the
1090
** second function argument.
1092
** The third argument must be one of the constants SQLITE_UTF8,
1093
** SQLITE_UTF16LE or SQLITE_UTF16BE, indicating that the user-supplied
1094
** routine expects to be passed pointers to strings encoded using UTF-8,
1095
** UTF-16 little-endian or UTF-16 big-endian respectively.
1097
** A pointer to the user supplied routine must be passed as the fifth
1098
** argument. If it is NULL, this is the same as deleting the collation
1099
** sequence (so that SQLite cannot call it anymore). Each time the user
1100
** supplied function is invoked, it is passed a copy of the void* passed as
1101
** the fourth argument to sqlite3_create_collation() or
1102
** sqlite3_create_collation16() as its first parameter.
1104
** The remaining arguments to the user-supplied routine are two strings,
1105
** each represented by a [length, data] pair and encoded in the encoding
1106
** that was passed as the third argument when the collation sequence was
1107
** registered. The user routine should return negative, zero or positive if
1108
** the first string is less than, equal to, or greater than the second
1109
** string. i.e. (STRING1 - STRING2).
1111
int sqlite3_create_collation(
1116
int(*xCompare)(void*,int,const void*,int,const void*)
1118
int sqlite3_create_collation16(
1123
int(*xCompare)(void*,int,const void*,int,const void*)
1127
** To avoid having to register all collation sequences before a database
1128
** can be used, a single callback function may be registered with the
1129
** database handle to be called whenever an undefined collation sequence is
1132
** If the function is registered using the sqlite3_collation_needed() API,
1133
** then it is passed the names of undefined collation sequences as strings
1134
** encoded in UTF-8. If sqlite3_collation_needed16() is used, the names
1135
** are passed as UTF-16 in machine native byte order. A call to either
1136
** function replaces any existing callback.
1138
** When the user-function is invoked, the first argument passed is a copy
1139
** of the second argument to sqlite3_collation_needed() or
1140
** sqlite3_collation_needed16(). The second argument is the database
1141
** handle. The third argument is one of SQLITE_UTF8, SQLITE_UTF16BE or
1142
** SQLITE_UTF16LE, indicating the most desirable form of the collation
1143
** sequence function required. The fourth parameter is the name of the
1144
** required collation sequence.
1146
** The collation sequence is returned to SQLite by a collation-needed
1147
** callback using the sqlite3_create_collation() or
1148
** sqlite3_create_collation16() APIs, described above.
1150
int sqlite3_collation_needed(
1153
void(*)(void*,sqlite3*,int eTextRep,const char*)
1155
int sqlite3_collation_needed16(
1158
void(*)(void*,sqlite3*,int eTextRep,const void*)
1162
** Specify the key for an encrypted database. This routine should be
1163
** called right after sqlite3_open().
1165
** The code to implement this API is not available in the public release
1169
sqlite3 *db, /* Database to be rekeyed */
1170
const void *pKey, int nKey /* The key */
1174
** Change the key on an open database. If the current database is not
1175
** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
1176
** database is decrypted.
1178
** The code to implement this API is not available in the public release
1182
sqlite3 *db, /* Database to be rekeyed */
1183
const void *pKey, int nKey /* The new key */
1187
** Sleep for a little while. The second parameter is the number of
1188
** miliseconds to sleep for.
1190
** If the operating system does not support sleep requests with
1191
** milisecond time resolution, then the time will be rounded up to
1192
** the nearest second. The number of miliseconds of sleep actually
1193
** requested from the operating system is returned.
1195
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1197
int sqlite3_sleep(int);
1200
** Return TRUE (non-zero) of the statement supplied as an argument needs
1201
** to be recompiled. A statement needs to be recompiled whenever the
1202
** execution environment changes in a way that would alter the program
1203
** that sqlite3_prepare() generates. For example, if new functions or
1204
** collating sequences are registered or if an authorizer function is
1205
** added or changed.
1207
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1209
int sqlite3_expired(sqlite3_stmt*);
1212
** If the following global variable is made to point to a
1213
** string which is the name of a directory, then all temporary files
1214
** created by SQLite will be placed in that directory. If this variable
1215
** is NULL pointer, then SQLite does a search for an appropriate temporary
1218
** Once sqlite3_open() has been called, changing this variable will invalidate
1219
** the current temporary database, if any.
1221
extern char *sqlite3_temp_directory;
1224
** This function is called to recover from a malloc() failure that occured
1225
** within the SQLite library. Normally, after a single malloc() fails the
1226
** library refuses to function (all major calls return SQLITE_NOMEM).
1227
** This function library state so that it can be used again.
1229
** All existing statements (sqlite3_stmt pointers) must be finalized or
1230
** reset before this call is made. Otherwise, SQLITE_BUSY is returned.
1231
** If any in-memory databases are in use, either as a main or TEMP
1232
** database, SQLITE_ERROR is returned. In either of these cases, the
1233
** library is not reset and remains unusable.
1235
** This function is *not* threadsafe. Calling this from within a threaded
1236
** application when threads other than the caller have used SQLite is
1237
** dangerous and will almost certainly result in malfunctions.
1239
** This functionality can be omitted from a build by defining the
1240
** SQLITE_OMIT_GLOBALRECOVER at compile time.
1242
int sqlite3_global_recover();
1245
} /* End of the 'extern "C"' block */
added
removed
src/3rdparty/sqlite/sqlite3.h
