Small. Fast. Reliable.
Choose any three.

About Sitemap Documentation Download License News Developers Support

This document contains the text of all requirements that define the operation of SQLite.

This document is currently a work in progress. It is incomplete and inaccurate. Check back later for further updates.

## Requirements

> F10010 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_VERSION         "3.5.6"
>     #define SQLITE_VERSION_NUMBER 3005006
F10011 | The SQLITE_VERSION #define in the sqlite3.h header file evaluates to a string literal that is the SQLite version with which the header file is associated.
F10014 | The SQLITE_VERSION_NUMBER #define resolves to an integer with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the major version, minor version, and release number.
> F10020 | The sqlite3.h header file defines the following interfaces:
>     SQLITE_EXTERN const char sqlite3_version[];
>     const char *sqlite3_libversion(void);
>     int sqlite3_libversion_number(void);
F10021 | The sqlite3_libversion_number() interface returns an integer equal to SQLITE_VERSION_NUMBER.
F10022 | The sqlite3_version string constant contains the text of the SQLITE_VERSION string.
F10023 | The sqlite3_libversion() function returns a pointer to the sqlite3_version string constant.
> F10100 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_threadsafe(void);
F10101 | The sqlite3_threadsafe() function returns nonzero if SQLite was compiled with its mutexes enabled or zero if SQLite was compiled with mutexes disabled.
> F10200 | The sqlite3.h header file defines the following interfaces:
>     #ifdef SQLITE_INT64_TYPE
>       typedef SQLITE_INT64_TYPE sqlite_int64;
>       typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
>     #elif defined(_MSC_VER) || defined(__BORLANDC__)
>       typedef __int64 sqlite_int64;
>       typedef unsigned __int64 sqlite_uint64;
>     #else
>       typedef long long int sqlite_int64;
>       typedef unsigned long long int sqlite_uint64;
>     #endif
>     typedef sqlite_int64 sqlite3_int64;
>     typedef sqlite_uint64 sqlite3_uint64;
F10201 | The sqlite_int64 and sqlite3_int64 types specify a 64-bit signed integer.
F10202 | The sqlite_uint64 and sqlite3_uint64 types specify a 64-bit unsigned integer.
> F10210 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_OK           0   /* Successful result */
>     /* beginning-of-error-codes */
>     #define SQLITE_ERROR        1   /* SQL error or missing database */
>     #define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
>     #define SQLITE_PERM         3   /* Access permission denied */
>     #define SQLITE_ABORT        4   /* Callback routine requested an abort */
>     #define SQLITE_BUSY         5   /* The database file is locked */
>     #define SQLITE_LOCKED       6   /* A table in the database is locked */
>     #define SQLITE_NOMEM        7   /* A malloc() failed */
>     #define SQLITE_READONLY     8   /* Attempt to write a readonly database */
>     #define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
>     #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
>     #define SQLITE_CORRUPT     11   /* The database disk image is malformed */
>     #define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */
>     #define SQLITE_FULL        13   /* Insertion failed because database is full */
>     #define SQLITE_CANTOPEN    14   /* Unable to open the database file */
>     #define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */
>     #define SQLITE_EMPTY       16   /* Database is empty */
>     #define SQLITE_SCHEMA      17   /* The database schema changed */
>     #define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
>     #define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
>     #define SQLITE_MISMATCH    20   /* Data type mismatch */
>     #define SQLITE_MISUSE      21   /* Library used incorrectly */
>     #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
>     #define SQLITE_AUTH        23   /* Authorization denied */
>     #define SQLITE_FORMAT      24   /* Auxiliary database format error */
>     #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
>     #define SQLITE_NOTADB      26   /* File opened that is not a database file */
>     #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
>     #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
>     /* end-of-error-codes */
> F10220 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_IOERR_READ          (SQLITE_IOERR | (1<<8))
>     #define SQLITE_IOERR_SHORT_READ    (SQLITE_IOERR | (2<<8))
>     #define SQLITE_IOERR_WRITE         (SQLITE_IOERR | (3<<8))
>     #define SQLITE_IOERR_FSYNC         (SQLITE_IOERR | (4<<8))
>     #define SQLITE_IOERR_DIR_FSYNC     (SQLITE_IOERR | (5<<8))
>     #define SQLITE_IOERR_TRUNCATE      (SQLITE_IOERR | (6<<8))
>     #define SQLITE_IOERR_FSTAT         (SQLITE_IOERR | (7<<8))
>     #define SQLITE_IOERR_UNLOCK        (SQLITE_IOERR | (8<<8))
>     #define SQLITE_IOERR_RDLOCK        (SQLITE_IOERR | (9<<8))
>     #define SQLITE_IOERR_DELETE        (SQLITE_IOERR | (10<<8))
>     #define SQLITE_IOERR_BLOCKED       (SQLITE_IOERR | (11<<8))
>     #define SQLITE_IOERR_NOMEM         (SQLITE_IOERR | (12<<8))
F10223 | The symbolic name for an extended result code always contains a related primary result code as a prefix.
F10224 | Primary result code names contain a single "_" character.
F10225 | Extended result code names contain two or more "_" characters.
F10226 | The numeric value of an extended result code contains the numeric value of its corresponding primary result code it its least significant 8 bits.
> F10230 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_OPEN_READONLY         0x00000001
>     #define SQLITE_OPEN_READWRITE        0x00000002
>     #define SQLITE_OPEN_CREATE           0x00000004
>     #define SQLITE_OPEN_DELETEONCLOSE    0x00000008
>     #define SQLITE_OPEN_EXCLUSIVE        0x00000010
>     #define SQLITE_OPEN_MAIN_DB          0x00000100
>     #define SQLITE_OPEN_TEMP_DB          0x00000200
>     #define SQLITE_OPEN_TRANSIENT_DB     0x00000400
>     #define SQLITE_OPEN_MAIN_JOURNAL     0x00000800
>     #define SQLITE_OPEN_TEMP_JOURNAL     0x00001000
>     #define SQLITE_OPEN_SUBJOURNAL       0x00002000
>     #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000
> F10240 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_IOCAP_ATOMIC          0x00000001
>     #define SQLITE_IOCAP_ATOMIC512       0x00000002
>     #define SQLITE_IOCAP_ATOMIC1K        0x00000004
>     #define SQLITE_IOCAP_ATOMIC2K        0x00000008
>     #define SQLITE_IOCAP_ATOMIC4K        0x00000010
>     #define SQLITE_IOCAP_ATOMIC8K        0x00000020
>     #define SQLITE_IOCAP_ATOMIC16K       0x00000040
>     #define SQLITE_IOCAP_ATOMIC32K       0x00000080
>     #define SQLITE_IOCAP_ATOMIC64K       0x00000100
>     #define SQLITE_IOCAP_SAFE_APPEND     0x00000200
>     #define SQLITE_IOCAP_SEQUENTIAL      0x00000400
> F10250 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_LOCK_NONE          0
>     #define SQLITE_LOCK_SHARED        1
>     #define SQLITE_LOCK_RESERVED      2
>     #define SQLITE_LOCK_PENDING       3
>     #define SQLITE_LOCK_EXCLUSIVE     4
> F10260 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_SYNC_NORMAL        0x00002
>     #define SQLITE_SYNC_FULL          0x00003
>     #define SQLITE_SYNC_DATAONLY      0x00010
> F10265 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_INTEGER  1
>     #define SQLITE_FLOAT    2
>     #define SQLITE_BLOB     4
>     #define SQLITE_NULL     5
>     #ifdef SQLITE_TEXT
>     # undef SQLITE_TEXT
>     #else
>     # define SQLITE_TEXT     3
>     #endif
>     #define SQLITE3_TEXT     3
> F10267 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_UTF8           1
>     #define SQLITE_UTF16LE        2
>     #define SQLITE_UTF16BE        3
>     #define SQLITE_UTF16          4    /* Use native byte order */
>     #define SQLITE_ANY            5    /* sqlite3_create_function only */
>     #define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
> F10280 | The sqlite3.h header file defines the following interfaces:
>     typedef void (*sqlite3_destructor_type)(void*);
>     #define SQLITE_STATIC      ((sqlite3_destructor_type)0)
>     #define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
> F10310 | The sqlite3.h header file defines the following interfaces:
>     SQLITE_EXTERN char *sqlite3_temp_directory;
> F10330 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_enable_shared_cache(int);
> F10510 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_complete(const char *sql);
>     int sqlite3_complete16(const void *sql);
F10511 | The sqlite3_complete() and sqlite3_complete16() functions return true (non-zero) if and only if the last non-whitespace token in their input is a semicolon that is not in between the BEGIN and END of a CREATE TRIGGER statement.
> F10530 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_sleep(int);
> F11110 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_file sqlite3_file;
>     struct sqlite3_file {
>       const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
>     };
> F11120 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_io_methods sqlite3_io_methods;
>     struct sqlite3_io_methods {
>       int iVersion;
>       int (*xClose)(sqlite3_file*);
>       int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
>       int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
>       int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
>       int (*xSync)(sqlite3_file*, int flags);
>       int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
>       int (*xLock)(sqlite3_file*, int);
>       int (*xUnlock)(sqlite3_file*, int);
>       int (*xCheckReservedLock)(sqlite3_file*);
>       int (*xFileControl)(sqlite3_file*, int op, void *pArg);
>       int (*xSectorSize)(sqlite3_file*);
>       int (*xDeviceCharacteristics)(sqlite3_file*);
>       /* Additional methods may be added in future releases */
>     };
> F11140 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_vfs sqlite3_vfs;
>     struct sqlite3_vfs {
>       int iVersion;            /* Structure version number */
>       int szOsFile;            /* Size of subclassed sqlite3_file */
>       int mxPathname;          /* Maximum file pathname length */
>       sqlite3_vfs *pNext;      /* Next registered VFS */
>       const char *zName;       /* Name of this virtual file system */
>       void *pAppData;          /* Pointer to application-specific data */
>       int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
>                    int flags, int *pOutFlags);
>       int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
>       int (*xAccess)(sqlite3_vfs*, const char *zName, int flags);
>       int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut);
>       int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
>       void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
>       void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
>       void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol);
>       void (*xDlClose)(sqlite3_vfs*, void*);
>       int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
>       int (*xSleep)(sqlite3_vfs*, int microseconds);
>       int (*xCurrentTime)(sqlite3_vfs*, double*);
>       /* New fields may be appended in figure versions.  The iVersion
>       ** value will increment whenever this happens. */
>     };
> F11190 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_ACCESS_EXISTS    0
>     #define SQLITE_ACCESS_READWRITE 1
>     #define SQLITE_ACCESS_READ      2
> F11200 | The sqlite3.h header file defines the following interfaces:
>     sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
>     int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
>     int sqlite3_vfs_unregister(sqlite3_vfs*);
> F11300 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
F11302 | The sqlite3_finalize(S) interface destroys the prepared statement S and releases all memory and file resources held by that object.
F11304 | If the most recent call to sqlite3_step(S) for the prepared statement S returned an error, then sqlite3_finalize(S) returns that same error.
> F11310 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_FCNTL_LOCKSTATE        1
> F11400 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_test_control(int op, ...);
> F11410 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_TESTCTRL_FAULT_CONFIG             1
>     #define SQLITE_TESTCTRL_FAULT_FAILURES           2
>     #define SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES    3
>     #define SQLITE_TESTCTRL_FAULT_PENDING            4
> F12000 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3 sqlite3;
> F12010 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_close(sqlite3 *);
F12011 | The sqlite3_close() interface destroys an sqlite3 object allocated by a prior call to sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
F12012 | The sqlite3_close() function releases all memory used by the connection and closes all open files.
F12013 | If the database connection contains prepared statements that have not been finalized by sqlite3_finalize(), then sqlite3_close() returns SQLITE_BUSY and leaves the connection open.
F12014 | Giving sqlite3_close() a NULL pointer is a harmless no-op.
> F12100 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_exec(
>       sqlite3*,                                  /* An open database */
>       const char *sql,                           /* SQL to be evaluted */
>       int (*callback)(void*,int,char**,char**),  /* Callback function */
>       void *,                                    /* 1st argument to callback */
>       char **errmsg                              /* Error msg written here */
>     );
F12101 | The sqlite3_exec() interface evaluates zero or more UTF-8 encoded, semicolon-separated, SQL statements in the zero-terminated string of its 2nd parameter within the context of the sqlite3 object given in the 1st parameter.
F12104 | The return value of sqlite3_exec() is SQLITE_OK if all SQL statements run successfully.
F12105 | The return value of sqlite3_exec() is an appropriate non-zero error code if any SQL statement fails.
F12107 | If one or more of the SQL statements handed to sqlite3_exec() return results and the 3rd parameter is not NULL, then the callback function specified by the 3rd parameter is invoked once for each row of result.
F12110 | If the callback returns a non-zero value then sqlite3_exec() will aborted the SQL statement it is currently evaluating, skip all subsequent SQL statements, and return SQLITE_ABORT. What happens to *errmsg here? Does the result code for sqlite3_errcode() get set?
F12113 | The sqlite3_exec() routine will pass its 4th parameter through as the 1st parameter of the callback.
F12116 | The sqlite3_exec() routine sets the 2nd parameter of its callback to be the number of columns in the current row of result.
F12119 | The sqlite3_exec() routine sets the 3rd parameter of its callback to be an array of pointers to strings holding the values for each column in the current result set row as obtained from sqlite3_column_text().
F12122 | The sqlite3_exec() routine sets the 4th parameter of its callback to be an array of pointers to strings holding the names of result columns as obtained from sqlite3_column_name().
F12125 | If the 3rd parameter to sqlite3_exec() is NULL then sqlite3_exec() never invokes a callback. All query results are silently discarded.
F12128 | If an error occurs while parsing or evaluating any of the SQL statements handed to sqlite3_exec() then sqlite3_exec() will return an error code other than SQLITE_OK.
F12131 | If an error occurs while parsing or evaluating any of the SQL handed to sqlite3_exec() and if the 5th parameter (errmsg) to sqlite3_exec() is not NULL, then an error message is allocated using the equivalent of sqlite3_mprintf() and *errmsg is made to point to that message.
F12134 | The sqlite3_exec() routine does not change the value of *errmsg if errmsg is NULL or if there are no errors.
F12137 | The sqlite3_exec() function sets the error code and message accessible via sqlite3_errcode() and sqlite3_errmsg().
> F12200 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_extended_result_codes(sqlite3*, int onoff);
F12201 | Each new database connection has the extended result codes feature disabled by default.
F12202 | The sqlite3_extended_result_codes(D,F) interface will enable extended result codes for the database connection D if the F parameter is true, or disable them if F is false.
> F12220 | The sqlite3.h header file defines the following interfaces:
>     sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
F12221 | The sqlite3_last_insert_rowid() function returns the rowid of the most recent successful insert done on the same database connection and within the same trigger context, or zero if there have been no qualifying inserts on that connection.
F12223 | The sqlite3_last_insert_rowid() function returns same value when called from the same trigger context immediately before and after a ROLLBACK.
> F12240 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_changes(sqlite3*);
F12241 | The sqlite3_changes() function returns the number of row changes caused by the most recent INSERT, UPDATE, or DELETE statement on the same database connection and within the same trigger context, or zero if there have not been any qualifying row changes.
> F12260 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_total_changes(sqlite3*);
F12261 | The sqlite3_total_changes() returns the total number of row changes caused by INSERT, UPDATE, and/or DELETE statements on the same database connection, in any trigger context, since the database connection was created.
> F12270 | The sqlite3.h header file defines the following interfaces:
>     void sqlite3_interrupt(sqlite3*);
F12271 | The sqlite3_interrupt() interface will force all running SQL statements associated with the same database connection to halt after processing at most one additional row of data.
F12272 | Any SQL statement that is interrupted by sqlite3_interrupt() will return SQLITE_INTERRUPT.
> F12280 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
>     void *sqlite3_profile(sqlite3*,
>        void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
F12281 | The callback function registered by sqlite3_trace() is whenever an SQL statement first begins to execute and whenever a trigger subprogram first begins to run.
F12282 | Each call to sqlite3_trace() overrides the previously registered trace callback.
F12283 | A NULL trace callback disables tracing.
F12284 | The first argument to the trace callback is a copy of the pointer which was the 3rd argument to sqlite3_trace().
F12285 | The second argument to the trace callback is a zero-terminated UTF8 string containing the original text of the SQL statement as it was passed into sqlite3_prepare_v2() or the equivalent, or an SQL comment indicating the beginning of a trigger subprogram.
F12287 | The callback function registered by sqlite3_profile() is invoked as each SQL statement finishes.
F12288 | The first parameter to the profile callback is a copy of the 3rd parameter to sqlite3_profile().
F12289 | The second parameter to the profile callback is a zero-terminated UTF-8 string that contains the complete text of the SQL statement as it was processed by sqlite3_prepare_v2() or the equivalent.
F12290 | The third parameter to the profile callback is an estimate of the number of nanoseconds of wall-clock time required to run the SQL statement from start to finish.
> F12310 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
F12311 | The sqlite3_busy_handler() function replaces the busy handler callback in the database connection identified by the 1st parameter with a new busy handler identified by the 2nd and 3rd parameters.
F12312 | The default busy handler for new database connections is NULL.
F12314 | When two or more database connection share a common cache, the busy handler for the database connection currently using the cache is invoked when the cache encounters a lock.
F12316 | If a busy handler callback returns zero, then the SQLite interface that provoked the locking event will return SQLITE_BUSY.
F12318 | SQLite will invokes the busy handler with two argument which are a copy of the pointer supplied by the 3rd parameter to sqlite3_busy_handler() and a count of the number of prior invocations of the busy handler for the same locking event.
> F12340 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_busy_timeout(sqlite3*, int ms);
F12341 | The sqlite3_busy_timeout() function overrides any prior sqlite3_busy_timeout() or sqlite3_busy_handler() setting on the same database connection.
F12343 | If the 2nd parameter to sqlite3_busy_timeout() is less than or equal to zero, then the busy handler is cleared so that all subsequent locking events immediately return SQLITE_BUSY.
F12344 | If the 2nd parameter to sqlite3_busy_timeout() is a positive number N, then a busy handler is set that repeatedly calls the xSleep() method in the VFS interface until either the lock clears or until the cumulative sleep time reported back by xSleep() exceeds N milliseconds.
> F12370 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_get_table(
>       sqlite3*,             /* An open database */
>       const char *sql,      /* SQL to be evaluated */
>       char ***pResult,      /* Results of the query */
>       int *nrow,            /* Number of result rows written here */
>       int *ncolumn,         /* Number of result columns written here */
>       char **errmsg         /* Error msg written here */
>     );
>     void sqlite3_free_table(char **result);
F12371 | If a sqlite3_get_table() fails a memory allocation, then it frees the result table under construction, aborts the query in process, skips any subsequent queries, sets the *resultp output pointer to NULL and returns SQLITE_NOMEM.
F12373 | If the ncolumn parameter to sqlite3_get_table() is not NULL then sqlite3_get_table() write the number of columns in the result set of the query into *ncolumn if the query is successful (if the function returns SQLITE_OK).
F12374 | If the nrow parameter to sqlite3_get_table() is not NULL then sqlite3_get_table() write the number of rows in the result set of the query into *nrow if the query is successful (if the function returns SQLITE_OK).
F12376 | The sqlite3_get_table() function sets its *ncolumn value to the number of columns in the result set of the query in the sql parameter, or to zero if the query in sql has an empty result set.
> F12500 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_set_authorizer(
>       sqlite3*,
>       int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
>       void *pUserData
>     );
F12501 | The sqlite3_set_authorizer(D,...) interface registers a authorizer callback with database connection D.
F12502 | The authorizer callback is invoked as SQL statements are being compiled
F12503 | If the authorizer callback returns any value other than SQLITE_IGNORE, SQLITE_OK, or SQLITE_DENY then the sqlite3_prepare_v2() or equivalent call that caused the authorizer callback to run shall fail with an SQLITE_ERROR error code and an appropriate error message.
F12504 | When the authorizer callback returns SQLITE_OK, the operation described is coded normally.
F12505 | When the authorizer callback returns SQLITE_DENY, the sqlite3_prepare_v2() or equivalent call that caused the authorizer callback to run shall fail with an SQLITE_ERROR error code and an error message explaining that access is denied.
F12506 | If the authorizer code (the 2nd parameter to the authorizer callback) is SQLITE_READ and the authorizer callback returns SQLITE_IGNORE then the prepared statement is constructed to insert a NULL value in place of the table column that would have been read if SQLITE_OK had been returned.
F12507 | If the authorizer code (the 2nd parameter to the authorizer callback) is anything other than SQLITE_READ, then a return of SQLITE_IGNORE has the same effect as SQLITE_DENY.
F12510 | The first parameter to the authorizer callback is a copy of the third parameter to the sqlite3_set_authorizer() interface.
F12511 | The second parameter to the callback is an integer action code that specifies the particular action to be authorized.
F12512 | The third through sixth parameters to the callback are zero-terminated strings that contain additional details about the action to be authorized.
F12520 | Each call to sqlite3_set_authorizer() overrides the any previously installed authorizer.
F12521 | A NULL authorizer means that no authorization callback is invoked.
F12522 | The default authorizer is NULL.
> F12550 | The sqlite3.h header file defines the following interfaces:
>     /******************************************* 3rd ************ 4th ***********/
>     #define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
>     #define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
>     #define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
>     #define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
>     #define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
>     #define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
>     #define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
>     #define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
>     #define SQLITE_DELETE                9   /* Table Name      NULL            */
>     #define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
>     #define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
>     #define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
>     #define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
>     #define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
>     #define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
>     #define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
>     #define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
>     #define SQLITE_INSERT               18   /* Table Name      NULL            */
>     #define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
>     #define SQLITE_READ                 20   /* Table Name      Column Name     */
>     #define SQLITE_SELECT               21   /* NULL            NULL            */
>     #define SQLITE_TRANSACTION          22   /* NULL            NULL            */
>     #define SQLITE_UPDATE               23   /* Table Name      Column Name     */
>     #define SQLITE_ATTACH               24   /* Filename        NULL            */
>     #define SQLITE_DETACH               25   /* Database Name   NULL            */
>     #define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
>     #define SQLITE_REINDEX              27   /* Index Name      NULL            */
>     #define SQLITE_ANALYZE              28   /* Table Name      NULL            */
>     #define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
>     #define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
>     #define SQLITE_FUNCTION             31   /* Function Name   NULL            */
>     #define SQLITE_COPY                  0   /* No longer used */
F12551 | The second parameter to an authorizer callback is always an integer [SQLITE_COPY that specifies what action is being authorized.
F12552 | The 3rd and 4th parameters to the authorization callback function will be parameters or NULL depending on which authorizer code is used as the second parameter.
F12553 | The 5th parameter to the authorizer callback is the name of the database (example: "main", "temp", etc.) if applicable.
F12554 | The 6th parameter to the authorizer callback is the name of the inner-most trigger or view that is responsible for the access attempt or NULL if this access attempt is directly from top-level SQL code.
> F12590 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_DENY   1   /* Abort the SQL statement with an error */
>     #define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
> F12600 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_load_extension(
>       sqlite3 *db,          /* Load the extension into this database connection */
>       const char *zFile,    /* Name of the shared library containing extension */
>       const char *zProc,    /* Entry point.  Derived from zFile if 0 */
>       char **pzErrMsg       /* Put error message here if not 0 */
>     );
> F12620 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
> F12640 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_auto_extension(void *xEntryPoint);
> F12660 | The sqlite3.h header file defines the following interfaces:
>     void sqlite3_reset_auto_extension(void);
> F12700 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_open(
>       const char *filename,   /* Database filename (UTF-8) */
>       sqlite3 **ppDb          /* OUT: SQLite db handle */
>     );
>     int sqlite3_open16(
>       const void *filename,   /* Database filename (UTF-16) */
>       sqlite3 **ppDb          /* OUT: SQLite db handle */
>     );
>     int sqlite3_open_v2(
>       const char *filename,   /* Database filename (UTF-8) */
>       sqlite3 **ppDb,         /* OUT: SQLite db handle */
>       int flags,              /* Flags */
>       const char *zVfs        /* Name of VFS module to use */
>     );
F12701 | The sqlite3_open(), sqlite3_open16(), and sqlite3_open_v2() interfaces create a new database connection associated with the database file given in their first parameter.
F12702 | The filename argument is interpreted as UTF-8 for sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte order for sqlite3_open16().
F12703 | A successful invocation of sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2() writes a pointer to a new database connection into *ppDb.
F12704 | The sqlite3_open(), sqlite3_open16(), and sqlite3_open_v2() interfaces return SQLITE_OK upon success, or an appropriate error code on failure.
F12706 | The default text encoding for a new database created using sqlite3_open() or sqlite3_open_v2() will be UTF-8.
F12707 | The default text encoding for a new database created using sqlite3_open16() will be UTF-16.
F12709 | The sqlite3_open(F,D) interface is equivalent to sqlite3_open_v2(F,D,G,0) where the G parameter is SQLITE_OPEN_READWRITE| SQLITE_OPEN_CREATE.
F12711 | If the G parameter to sqlite3_open_v2(F,D,G,V) contains the bit value SQLITE_OPEN_READONLY then the database is opened for reading only.
F12712 | If the G parameter to sqlite3_open_v2(F,D,G,V) contains the bit value SQLITE_OPEN_READWRITE then the database is opened reading and writing if possible, or for reading only if the file is write protected by the operating system.
F12713 | If the G parameter to sqlite3_open(v2(F,D,G,V) omits the bit value SQLITE_OPEN_CREATE and the database does not previously exist, an error is returned.
F12714 | If the G parameter to sqlite3_open(v2(F,D,G,V) contains the bit value SQLITE_OPEN_CREATE and the database does not previously exist, then an attempt is made to create and initialize the database.
F12717 | If the filename argument to sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2() is ":memory:", then an private, ephemeral, in-memory database is created for the connection. Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required in sqlite3_open_v2()?
F12719 | If the filename is an empty string, then a private, ephermeral on-disk database will be created. Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required in sqlite3_open_v2()?
F12721 | The database connection created by sqlite3_open_v2(F,D,G,V) will use the sqlite3_vfs object identified by the V parameter, or the default sqlite3_vfs object is V is a NULL pointer.
> F12800 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_errcode(sqlite3 *db);
>     const char *sqlite3_errmsg(sqlite3*);
>     const void *sqlite3_errmsg16(sqlite3*);
F12801 | The sqlite3_errcode(D) interface returns the numeric result code or extended result code for the most recent failed interface call associated with sqlite3 handle D.
F12803 | The sqlite3_errmsg(D) and sqlite3_errmsg16(D) interfaces return English-language text that describes the error in the mostly recently failed interface call, encoded as either UTF8 or UTF16 respectively.
F12807 | Calls to sqlite3_errcode(), sqlite3_errmsg(), and sqlite3_errmsg16() themselves do not affect the results of future invocations of these routines.
F12808 | Calls to API routines that do not return an error code (example: sqlite3_data_count()) do not change the error code or message returned by sqlite3_errcode(), sqlite3_errmsg(), or sqlite3_errmsg16().
F12809 | Interfaces that are not associated with a specific database connection (examples: sqlite3_mprintf() or sqlite3_enable_shared_cache() do not change the values returned by sqlite3_errcode(), sqlite3_errmsg(), or sqlite3_errmsg16().
> F12850 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_table_column_metadata(
>       sqlite3 *db,                /* Connection handle */
>       const char *zDbName,        /* Database name or NULL */
>       const char *zTableName,     /* Table name */
>       const char *zColumnName,    /* Column name */
>       char const **pzDataType,    /* OUTPUT: Declared data type */
>       char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
>       int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
>       int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
>       int *pAutoinc               /* OUTPUT: True if column is auto-increment */
>     );
> F12910 | The sqlite3.h header file defines the following interfaces:
>     void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
F12911 | The callback function registered by sqlite3_progress_handler() is invoked periodically during long running calls to sqlite3_step().
F12912 | The progress callback is invoked once for every N virtual machine opcodes, where N is the second argument to the sqlite3_progress_handler() call that registered the callback. What if N is less than 1?
F12913 | The progress callback itself is identified by the third argument to sqlite3_progress_handler().
F12914 | The fourth argument sqlite3_progress_handler() is a void pointer passed to the progress callback function each time it is invoked.
F12915 | If a call to sqlite3_step() results in fewer than N opcodes being executed, then the progress callback is never invoked. {END}
F12916 | Every call to sqlite3_progress_handler() overwrites any previously registere progress handler.
F12917 | If the progress handler callback is NULL then no progress handler is invoked.
F12918 | If the progress callback returns a result other than 0, then the behavior is a if sqlite3_interrupt() had been called.
> F12930 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_get_autocommit(sqlite3*);
F12931 | The sqlite3_get_autocommit() interface returns non-zero or zero if the given database connection is or is not in autocommit mode, respectively.
F12932 | Autocommit mode is on by default.
F12933 | Autocommit mode is disabled by a successful BEGIN statement.
F12934 | Autocommit mode is enabled by a successful COMMIT or ROLLBACK statement.
> F12950 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
>     void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
> F12970 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_update_hook(
>       sqlite3*,
>       void(*)(void *,int ,char const *,char const *,sqlite3_int64),
>       void*
>     );
> F13000 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_stmt sqlite3_stmt;
> F13010 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_prepare(
>       sqlite3 *db,            /* Database handle */
>       const char *zSql,       /* SQL statement, UTF-8 encoded */
>       int nByte,              /* Maximum length of zSql in bytes. */
>       sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
>       const char **pzTail     /* OUT: Pointer to unused portion of zSql */
>     );
>     int sqlite3_prepare_v2(
>       sqlite3 *db,            /* Database handle */
>       const char *zSql,       /* SQL statement, UTF-8 encoded */
>       int nByte,              /* Maximum length of zSql in bytes. */
>       sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
>       const char **pzTail     /* OUT: Pointer to unused portion of zSql */
>     );
>     int sqlite3_prepare16(
>       sqlite3 *db,            /* Database handle */
>       const void *zSql,       /* SQL statement, UTF-16 encoded */
>       int nByte,              /* Maximum length of zSql in bytes. */
>       sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
>       const void **pzTail     /* OUT: Pointer to unused portion of zSql */
>     );
>     int sqlite3_prepare16_v2(
>       sqlite3 *db,            /* Database handle */
>       const void *zSql,       /* SQL statement, UTF-16 encoded */
>       int nByte,              /* Maximum length of zSql in bytes. */
>       sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
>       const void **pzTail     /* OUT: Pointer to unused portion of zSql */
>     );
F13011 | The sqlite3_prepare(db,zSql,...) and sqlite3_prepare_v2(db,zSql,...) interfaces interpret the text in their zSql parameter as UTF-8.
F13012 | The sqlite3_prepare16(db,zSql,...) and sqlite3_prepare16_v2(db,zSql,...) interfaces interpret the text in their zSql parameter as UTF-16 in the native byte order.
F13013 | If the nByte argument to sqlite3_prepare_v2(db,zSql,nByte,...) and its variants is less than zero, then SQL text is read from zSql is read up to the first zero terminator.
F13014 | If the nByte argument to sqlite3_prepare_v2(db,zSql,nByte,...) and its variants is non-negative, then nBytes bytes SQL text is read from zSql.
F13015 | In sqlite3_prepare_v2(db,zSql,N,P,pzTail) and its variants if the zSql input text contains more than one SQL statement and pzTail is not NULL, then *pzTail is made to point to the first byte past the end of the first SQL statement in zSql. What does *pzTail point to if there is one statement?
F13016 | A successful call to sqlite3_prepare_v2(db,zSql,N,ppStmt,...) or one of its variants writes into *ppStmt a pointer to a new prepared statement or a pointer to NULL if zSql contains nothing other than whitespace or comments.
F13019 | The sqlite3_prepare_v2() interface and its variants return SQLITE_OK or an appropriate error code upon failure.
> F13120 | The sqlite3.h header file defines the following interfaces:
>     sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
> F13200 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_step(sqlite3_stmt*);
F13202 | If prepared statement S is ready to be run, then sqlite3_step(S) advances that prepared statement until to completion or until it is ready to return another row of the result set or an interrupt or run-time error occurs.
> F13300 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_finalize(sqlite3_stmt *pStmt);
> F13330 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_reset(sqlite3_stmt *pStmt);
> F13500 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
>     int sqlite3_bind_double(sqlite3_stmt*, int, double);
>     int sqlite3_bind_int(sqlite3_stmt*, int, int);
>     int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
>     int sqlite3_bind_null(sqlite3_stmt*, int);
>     int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
>     int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
>     int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
>     int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
F13506 | The SQL statement compiler recognizes tokens of the forms "?", "?NNN", "$VVV", ":VVV", and "@VVV" as SQL parameters, where NNN is any sequence of one or more digits and where VVV is any sequence of one or more alphanumeric characters or "::" optionally followed by a string containing no spaces and contained within parentheses.
F13509 | The initial value of an SQL parameter is NULL.
F13512 | The index of an "?" SQL parameter is one larger than the largest index of SQL parameter to the left, or 1 if the "?" is the leftmost SQL parameter.
F13515 | The index of an "?NNN" SQL parameter is the integer NNN.
F13518 | The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is the same as the index of leftmost occurances of the same parameter, or one more than the largest index over all parameters to the left if this is the first occurrance of this parameter, or 1 if this is the leftmost parameter.
F13521 | The SQL statement compiler fail with an SQLITE_RANGE error if the index of an SQL parameter is less than 1 or greater than SQLITE_MAX_VARIABLE_NUMBER.
F13524 | Calls to sqlite3_bind(S,N,V,...) associate the value V with all SQL parameters having an index of N in the prepared statement S.
F13527 | Calls to sqlite3_bind(S,N,...) override prior calls with the same values of S and N.
F13530 | Bindings established by sqlite3_bind(S,...) persist across calls to sqlite3_reset(S).
F13533 | In calls to sqlite3_bind_blob(S,N,V,L,D), sqlite3_bind_text(S,N,V,L,D), or sqlite3_bind_text16(S,N,V,L,D) SQLite binds the first L bytes of the blob or string pointed to by V, when L is non-negative.
F13536 | In calls to sqlite3_bind_text(S,N,V,L,D) or sqlite3_bind_text16(S,N,V,L,D) SQLite binds characters from V through the first zero character when L is negative.
F13539 | In calls to sqlite3_bind_blob(S,N,V,L,D), sqlite3_bind_text(S,N,V,L,D), or sqlite3_bind_text16(S,N,V,L,D) when D is the special constant SQLITE_STATIC, SQLite assumes that the value V is held in static unmanaged space that will not change during the lifetime of the binding.
F13542 | In calls to sqlite3_bind_blob(S,N,V,L,D), sqlite3_bind_text(S,N,V,L,D), or sqlite3_bind_text16(S,N,V,L,D) when D is the special constant SQLITE_TRANSIENT, the routine makes a private copy of V value before it returns.
F13545 | In calls to sqlite3_bind_blob(S,N,V,L,D), sqlite3_bind_text(S,N,V,L,D), or sqlite3_bind_text16(S,N,V,L,D) when D is a pointer to a function, SQLite invokes that function to destroy the V value after it has finished using the V value.
F13548 | In calls to sqlite3_bind_zeroblob(S,N,V,L) the value bound is a blob of L bytes, or a zero-length blob if L is negative.
> F13600 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_bind_parameter_count(sqlite3_stmt*);
F13601 | The sqlite3_bind_parameter_count(S) interface returns the largest index of all SQL parameters in the prepared statement S, or 0 if S contains no SQL parameters.
> F13620 | The sqlite3.h header file defines the following interfaces:
>     const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
F13621 | The sqlite3_bind_parameter_name(S,N) interface returns a UTF-8 rendering of the name of the SQL parameter in prepared statement S having index N, or NULL if there is no SQL parameter with index N or if the parameter with index N is an anonymous parameter "?" or a numbered parameter "?NNN".
> F13640 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
F13641 | The sqlite3_bind_parameter_index(S,N) interface returns the index of SQL parameter in prepared statement S whose name matches the UTF-8 string N, or 0 if there is no match.
> F13660 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_clear_bindings(sqlite3_stmt*);
F13661 | The sqlite3_clear_bindings(S) interface resets all SQL parameter bindings in prepared statement S back to NULL.
> F13710 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_column_count(sqlite3_stmt *pStmt);
F13711 | The sqlite3_column_count(S) interface returns the number of columns in the result set generated by the prepared statement S, or 0 if S does not generate a result set.
> F13720 | The sqlite3.h header file defines the following interfaces:
>     const char *sqlite3_column_name(sqlite3_stmt*, int N);
>     const void *sqlite3_column_name16(sqlite3_stmt*, int N);
F13721 | A successful invocation of the sqlite3_column_name(S,N) interface returns the name of the Nth column (where 0 is the left-most column) for the result set of prepared statement S as a zero-terminated UTF-8 string.
F13723 | A successful invocation of the sqlite3_column_name16(S,N) interface returns the name of the Nth column (where 0 is the left-most column) for the result set of prepared statement S as a zero-terminated UTF-16 string in the native byte order.
F13724 | The sqlite3_column_name() and sqlite3_column_name16() interfaces return a NULL pointer if they are unable to allocate memory memory to hold there normal return strings.
F13725 | If the N parameter to sqlite3_column_name(S,N) or sqlite3_column_name16(S,N) is out of range, then the interfaces returns a NULL pointer.
F13726 | The strings returned by sqlite3_column_name(S,N) and sqlite3_column_name16(S,N) are valid until the next call to either routine with the same S and N parameters or until sqlite3_finalize(S) is called.
F13727 | When a result column of a SELECT statement contains an AS clause, the name of that column is the indentifier to the right of the AS keyword.
> F13740 | The sqlite3.h header file defines the following interfaces:
>     const char *sqlite3_column_database_name(sqlite3_stmt*,int);
>     const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
>     const char *sqlite3_column_table_name(sqlite3_stmt*,int);
>     const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
>     const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
>     const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
F13741 | The sqlite3_column_database_name(S,N) interface returns either the UTF-8 zero-terminated name of the database from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13742 | The sqlite3_column_database_name16(S,N) interface returns either the UTF-16 native byte order zero-terminated name of the database from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13743 | The sqlite3_column_table_name(S,N) interface returns either the UTF-8 zero-terminated name of the table from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13744 | The sqlite3_column_table_name16(S,N) interface returns either the UTF-16 native byte order zero-terminated name of the table from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13745 | The sqlite3_column_origin_name(S,N) interface returns either the UTF-8 zero-terminated name of the table column from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13746 | The sqlite3_column_origin_name16(S,N) interface returns either the UTF-16 native byte order zero-terminated name of the table column from which the Nth result column of prepared statement S is extracted, or NULL if the the Nth column of S is a general expression or if unable to allocate memory to store the name.
F13748 | The return values from column metadata interfaces are valid for the lifetime of the prepared statement or until the encoding is changed by another metadata interface call for the same prepared statement and column.
> F13760 | The sqlite3.h header file defines the following interfaces:
>     const char *sqlite3_column_decltype(sqlite3_stmt*,int);
>     const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
F13761 | A successful call to sqlite3_column_decltype(S,N) returns a zero-terminated UTF-8 string containing the the declared datatype of the table column that appears as the Nth column (numbered from 0) of the result set to the prepared statement S.
F13762 | A successful call to sqlite3_column_decltype16(S,N) returns a zero-terminated UTF-16 native byte order string containing the declared datatype of the table column that appears as the Nth column (numbered from 0) of the result set to the prepared statement S.
F13763 | If N is less than 0 or N is greater than or equal to the number of columns in prepared statement S or if the Nth column of S is an expression or subquery rather than a table column or if a memory allocation failure occurs during encoding conversions, then calls to sqlite3_column_decltype(S,N) or sqlite3_column_decltype16(S,N) return NULL.
> F13770 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_data_count(sqlite3_stmt *pStmt);
F13771 | After a call to sqlite3_step(S) that returns SQLITE_ROW, the sqlite3_data_count(S) routine will return the same value as the sqlite3_column_count(S) function.
F13772 | After sqlite3_step(S) has returned any value other than SQLITE_ROW or before sqlite3_step(S) has been called on the prepared statement for the first time since it was prepared or reset, the sqlite3_data_count(S) routine returns zero.
> F13800 | The sqlite3.h header file defines the following interfaces:
>     const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
>     int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
>     int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
>     double sqlite3_column_double(sqlite3_stmt*, int iCol);
>     int sqlite3_column_int(sqlite3_stmt*, int iCol);
>     sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
>     const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
>     const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
>     int sqlite3_column_type(sqlite3_stmt*, int iCol);
>     sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
F13803 | The sqlite3_column_blob(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a blob and then returns a pointer to the converted value.
F13806 | The sqlite3_column_bytes(S,N) interface returns the number of bytes in the blob or string (exclusive of the zero terminator on the string) that was returned by the most recent call to sqlite3_column_blob(S,N) or sqlite3_column_text(S,N).
F13809 | The sqlite3_column_bytes16(S,N) interface returns the number of bytes in the string (exclusive of the zero terminator on the string) that was returned by the most recent call to sqlite3_column_text16(S,N).
F13812 | The sqlite3_column_double(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a floating point value and returns a copy of that value.
F13815 | The sqlite3_column_int(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a 32-bit signed integer and returns a copy of that integer.
F13818 | The sqlite3_column_int64(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a 64-bit signed integer and returns a copy of that integer.
F13821 | The sqlite3_column_text(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a zero-terminated UTF-8 string and returns a pointer to that string.
F13824 | The sqlite3_column_text16(S,N) interface converts the Nth column in the current row of the result set for prepared statement S into a zero-terminated 2-byte aligned UTF-16 native byte order string and returns a pointer to that string.
F13827 | The sqlite3_column_type(S,N) interface returns one of SQLITE_NULL, SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, or SQLITE_BLOB as appropriate for the Nth column in the current row of the result set for prepared statement S.
F13830 | The sqlite3_column_value(S,N) interface returns a pointer to the sqlite3_value object that for the Nth column in the current row of the result set for prepared statement S.
> F15000 | The sqlite3.h header file defines the following interfaces:
>     typedef struct Mem sqlite3_value;
> F15100 | The sqlite3.h header file defines the following interfaces:
>     const void *sqlite3_value_blob(sqlite3_value*);
>     int sqlite3_value_bytes(sqlite3_value*);
>     int sqlite3_value_bytes16(sqlite3_value*);
>     double sqlite3_value_double(sqlite3_value*);
>     int sqlite3_value_int(sqlite3_value*);
>     sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
>     const unsigned char *sqlite3_value_text(sqlite3_value*);
>     const void *sqlite3_value_text16(sqlite3_value*);
>     const void *sqlite3_value_text16le(sqlite3_value*);
>     const void *sqlite3_value_text16be(sqlite3_value*);
>     int sqlite3_value_type(sqlite3_value*);
>     int sqlite3_value_numeric_type(sqlite3_value*);
F15304 | When a call to sqlite3_step(S) causes the prepared statement S to run to completion, the function returns SQLITE_DONE.
F15306 | When a call to sqlite3_step(S) stops because it is ready to return another row of the result set, it returns SQLITE_ROW.
F15308 | If a call to sqlite3_step(S) encounters an interrupt or a run-time error, it returns an appropraite error code that is not one of SQLITE_OK, SQLITE_ROW, or SQLITE_DONE.
F15310 | If an interrupt or run-time error occurs during a call to sqlite3_step(S) for a prepared statement S created using legacy interfaces sqlite3_prepare() or sqlite3_prepare16() then the function returns either SQLITE_ERROR, SQLITE_BUSY, or SQLITE_MISUSE.
> F16001 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_context sqlite3_context;
> F16100 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_create_function(
>       sqlite3 *db,
>       const char *zFunctionName,
>       int nArg,
>       int eTextRep,
>       void *pApp,
>       void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
>       void (*xStep)(sqlite3_context*,int,sqlite3_value**),
>       void (*xFinal)(sqlite3_context*)
>     );
>     int sqlite3_create_function16(
>       sqlite3 *db,
>       const void *zFunctionName,
>       int nArg,
>       int eTextRep,
>       void *pApp,
>       void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
>       void (*xStep)(sqlite3_context*,int,sqlite3_value**),
>       void (*xFinal)(sqlite3_context*)
>     );
F16103 | The sqlite3_create_function16() interface behaves exactly like sqlite3_create_function() in every way except that it interprets the zFunctionName argument as zero-terminated UTF-16 native byte order instead of as a zero-terminated UTF-8. {F16106}
> F16210 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
> F16240 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_user_data(sqlite3_context*);
> F16270 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_get_auxdata(sqlite3_context*, int N);
>     void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
> F16400 | The sqlite3.h header file defines the following interfaces:
>     void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
>     void sqlite3_result_double(sqlite3_context*, double);
>     void sqlite3_result_error(sqlite3_context*, const char*, int);
>     void sqlite3_result_error16(sqlite3_context*, const void*, int);
>     void sqlite3_result_error_toobig(sqlite3_context*);
>     void sqlite3_result_error_nomem(sqlite3_context*);
>     void sqlite3_result_error_code(sqlite3_context*, int);
>     void sqlite3_result_int(sqlite3_context*, int);
>     void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
>     void sqlite3_result_null(sqlite3_context*);
>     void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
>     void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
>     void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
>     void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
>     void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
>     void sqlite3_result_zeroblob(sqlite3_context*, int n);
> F16600 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_create_collation(
>       sqlite3*,
>       const char *zName,
>       int eTextRep,
>       void*,
>       int(*xCompare)(void*,int,const void*,int,const void*)
>     );
>     int sqlite3_create_collation_v2(
>       sqlite3*,
>       const char *zName,
>       int eTextRep,
>       void*,
>       int(*xCompare)(void*,int,const void*,int,const void*),
>       void(*xDestroy)(void*)
>     );
>     int sqlite3_create_collation16(
>       sqlite3*,
>       const char *zName,
>       int eTextRep,
>       void*,
>       int(*xCompare)(void*,int,const void*,int,const void*)
>     );
> F16700 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_collation_needed(
>       sqlite3*,
>       void*,
>       void(*)(void*,sqlite3*,int eTextRep,const char*)
>     );
>     int sqlite3_collation_needed16(
>       sqlite3*,
>       void*,
>       void(*)(void*,sqlite3*,int eTextRep,const void*)
>     );
> F17000 | The sqlite3.h header file defines the following interfaces:
>     sqlite3_mutex *sqlite3_mutex_alloc(int);
>     void sqlite3_mutex_free(sqlite3_mutex*);
>     void sqlite3_mutex_enter(sqlite3_mutex*);
>     int sqlite3_mutex_try(sqlite3_mutex*);
>     void sqlite3_mutex_leave(sqlite3_mutex*);
> F17001 | The sqlite3.h header file defines the following interfaces:
>     #define SQLITE_MUTEX_FAST             0
>     #define SQLITE_MUTEX_RECURSIVE        1
>     #define SQLITE_MUTEX_STATIC_MASTER    2
>     #define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
>     #define SQLITE_MUTEX_STATIC_MEM2      4  /* sqlite3_release_memory() */
>     #define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
>     #define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
> F17080 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_mutex_held(sqlite3_mutex*);
>     int sqlite3_mutex_notheld(sqlite3_mutex*);
> F17110 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_mutex sqlite3_mutex;
> F17300 | The sqlite3.h header file defines the following interfaces:
>     void *sqlite3_malloc(int);
>     void *sqlite3_realloc(void*, int);
>     void sqlite3_free(void*);
F17303 | The sqlite3_malloc(N) interface returns either a pointer to newly checked-out block of at least N bytes of memory that is 8-byte aligned, or it returns NULL if it is unable to fulfill the request.
F17304 | The sqlite3_malloc(N) interface returns a NULL pointer if N is less than or equal to zero.
F17305 | The sqlite3_free(P) interface releases memory previously returned from sqlite3_malloc() or sqlite3_realloc(), making it available for reuse.
F17306 | A call to sqlite3_free(NULL) is a harmless no-op.
F17310 | A call to sqlite3_realloc(0,N) is equivalent to a call to sqlite3_malloc(N).
F17312 | A call to sqlite3_realloc(P,0) is equivalent to a call to sqlite3_free(P).
F17315 | The SQLite core uses sqlite3_malloc(), sqlite3_realloc(), and sqlite3_free() for all of its memory allocation and deallocation needs.
F17318 | The sqlite3_realloc(P,N) interface returns either a pointer to a block of checked-out memory of at least N bytes in size that is 8-byte aligned, or a NULL pointer.
F17321 | When sqlite3_realloc(P,N) returns a non-NULL pointer, it first copies the first K bytes of content from P into the newly allocated where K is the lessor of N and the size of the buffer P.
F17322 | When sqlite3_realloc(P,N) returns a non-NULL pointer, it first releases the buffer P.
F17323 | When sqlite3_realloc(P,N) returns NULL, the buffer P is not modified or released.
> F17340 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_release_memory(int);
> F17350 | The sqlite3.h header file defines the following interfaces:
>     void sqlite3_soft_heap_limit(int);
> F17370 | The sqlite3.h header file defines the following interfaces:
>     sqlite3_int64 sqlite3_memory_used(void);
>     sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
F17371 | The sqlite3_memory_used() routine returns the number of bytes of memory currently outstanding (malloced but not freed).
F17373 | The sqlite3_memory_highwater() routine returns the maximum value of sqlite3_memory_used() since the highwater mark was last reset.
F17374 | The values returned by sqlite3_memory_used() and sqlite3_memory_highwater() include any overhead added by SQLite in its implementation of sqlite3_malloc(), but not overhead added by the any underlying system library routines that sqlite3_malloc() may call.
F17375 | The memory highwater mark is reset to the current value of sqlite3_memory_used() if and only if the parameter to sqlite3_memory_highwater() is true. The value returned by sqlite3_memory_highwater(1) is the highwater mark prior to the reset.
> F17400 | The sqlite3.h header file defines the following interfaces:
>     char *sqlite3_mprintf(const char*,...);
>     char *sqlite3_vmprintf(const char*, va_list);
>     char *sqlite3_snprintf(int,char*,const char*, ...);
F17403 | The sqlite3_mprintf() and sqlite3_vmprintf() interfaces return either pointers to zero-terminated UTF-8 strings held in memory obtained from sqlite3_malloc() or NULL pointers if a call to sqlite3_malloc() fails.
F17406 | The sqlite3_snprintf() interface writes a zero-terminated UTF-8 string into the buffer pointed to by the second parameter provided that the first parameter is greater than zero.
F17407 | The sqlite3_snprintf() interface does not writes slots of its output buffer (the second parameter) outside the range of 0 through N-1 (where N is the first parameter) regardless of the length of the string requested by the format specification.
> F17800 | The sqlite3.h header file defines the following interfaces:
>     typedef struct sqlite3_blob sqlite3_blob;
> F17805 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_blob_bytes(sqlite3_blob *);
> F17810 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_blob_open(
>       sqlite3*,
>       const char *zDb,
>       const char *zTable,
>       const char *zColumn,
>       sqlite3_int64 iRow,
>       int flags,
>       sqlite3_blob **ppBlob
>     );
> F17830 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_blob_close(sqlite3_blob *);
> F17850 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset);
> F17870 | The sqlite3.h header file defines the following interfaces:
>     int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
U10512 | The input to sqlite3_complete() must be a zero-terminated UTF-8 string.
U10513 | The input to sqlite3_complete16() must be a zero-terminated UTF-16 string in native byte order.
U12015 | The parameter to sqlite3_close() must be an sqlite3 object pointer previously obtained from sqlite3_open() or the equivalent, or NULL.
U12016 | The parameter to sqlite3_close() must not have been previously closed.
U12141 | The first parameter to sqlite3_exec() must be an valid and open database connection.
U12142 | The database connection must not be closed while sqlite3_exec() is running.
U12143 | The calling function is should use sqlite3_free() to free the memory that *errmsg is left pointing at once the error message is no longer needed.
U12145 | The SQL statement text in the 2nd parameter to sqlite3_exec() must remain unchanged while sqlite3_exec() is running.
U12232 | If separate thread does a new insert on the same database connection while the sqlite3_last_insert_rowid() function is running and thus changes the last insert rowid, then the value returned by sqlite3_last_insert_rowid() is unpredictable and might not equal either the old or the new last insert rowid.
U12252 | If a separate thread makes changes on the same database connection while sqlite3_changes() is running then the value returned is unpredictable and unmeaningful.
U12264 | If a separate thread makes changes on the same database connection while sqlite3_total_changes() is running then the value returned is unpredictable and unmeaningful.
U12279 | If the database connection closes while sqlite3_interrupt() is running then bad things will likely happen.
U12319 | A busy handler should not call close the database connection or prepared statement that invoked the busy handler.
U12802 | If a prior API call failed but the most recent API call succeeded, the return value from sqlite3_errcode(), sqlite3_errmsg(), and sqlite3_errmsg16() are undefined.
U12804 | The strings returned by sqlite3_errmsg() and sqlite3_errmsg16() are only valid until the next SQLite interface call.
U12936 | If another thread changes the autocommit status of the database connection while this routine is running, then the return value is undefined.
U13751 | If two or more threads call one or more column metadata interfaces the same prepared statement and result column at the same time then the results are undefined.
U17350 | The pointer arguments to sqlite3_free() and sqlite3_realloc() must be either NULL or else a pointer obtained from a prior invocation of sqlite3_malloc() or sqlite3_realloc() that has not been released.
U17351 | The application must not read or write any part of a block of memory after it has been released using sqlite3_free() or sqlite3_realloc().

This page last modified 2008/01/30 17:07:56 UTC