#include <stdarg.h>

Include dependency graph for sqlite3.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	sqlite3_file
struct	sqlite3_io_methods
struct	sqlite3_vfs
struct	sqlite3_mem_methods
struct	sqlite3_module
struct	sqlite3_index_info
struct	sqlite3_index_info::sqlite3_index_constraint
struct	sqlite3_index_info::sqlite3_index_orderby
struct	sqlite3_index_info::sqlite3_index_constraint_usage
struct	sqlite3_vtab
struct	sqlite3_vtab_cursor
struct	sqlite3_mutex_methods
struct	sqlite3_pcache_page
struct	sqlite3_pcache_methods2
struct	sqlite3_pcache_methods
struct	sqlite3_snapshot
struct	sqlite3_rtree_geometry
struct	sqlite3_rtree_query_info
struct	Fts5PhraseIter
struct	Fts5ExtensionApi
struct	fts5_tokenizer_v2
struct	fts5_tokenizer
struct	fts5_api

Macros
#define	SQLITE_EXTERN extern
#define	SQLITE_API
#define	SQLITE_CDECL
#define	SQLITE_APICALL
#define	SQLITE_STDCALL SQLITE_APICALL
#define	SQLITE_CALLBACK
#define	SQLITE_SYSAPI
#define	SQLITE_DEPRECATED
#define	SQLITE_EXPERIMENTAL
#define	SQLITE_VERSION "3.50.2"
#define	SQLITE_VERSION_NUMBER 3050002
#define	SQLITE_SOURCE_ID "2025-06-28 14:00:48 2af157d77fb1304a74176eaee7fbc7c7e932d946bf25325e9c26c91db19e3079"
#define	SQLITE_OK 0 /* Successful result */
#define	SQLITE_ERROR 1 /* Generic error */
#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 /* Unknown opcode in sqlite3_file_control() */
#define	SQLITE_FULL 13 /* Insertion failed because database is full */
#define	SQLITE_CANTOPEN 14 /* Unable to open the database file */
#define	SQLITE_PROTOCOL 15 /* Database lock protocol error */
#define	SQLITE_EMPTY 16 /* Internal use only */
#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 /* Not used */
#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_NOTICE 27 /* Notifications from sqlite3_log() */
#define	SQLITE_WARNING 28 /* Warnings from sqlite3_log() */
#define	SQLITE_ROW 100 /* sqlite3_step() has another row ready */
#define	SQLITE_DONE 101 /* sqlite3_step() has finished executing */
#define	SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR \| (1<<8))
#define	SQLITE_ERROR_RETRY (SQLITE_ERROR \| (2<<8))
#define	SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR \| (3<<8))
#define	SQLITE_IOERR_READ (SQLITE_IOERR \| (1<<8))
#define	SQLITE_IOERR_SHORT_READ (SQLITE_IOERR \| (2<<8))
#define	SQLITE_IOERR_WRITE (SQLITE_IOERR \| (3<<8))
#define	SQLITE_IOERR_FSYNC (SQLITE_IOERR \| (4<<8))
#define	SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR \| (5<<8))
#define	SQLITE_IOERR_TRUNCATE (SQLITE_IOERR \| (6<<8))
#define	SQLITE_IOERR_FSTAT (SQLITE_IOERR \| (7<<8))
#define	SQLITE_IOERR_UNLOCK (SQLITE_IOERR \| (8<<8))
#define	SQLITE_IOERR_RDLOCK (SQLITE_IOERR \| (9<<8))
#define	SQLITE_IOERR_DELETE (SQLITE_IOERR \| (10<<8))
#define	SQLITE_IOERR_BLOCKED (SQLITE_IOERR \| (11<<8))
#define	SQLITE_IOERR_NOMEM (SQLITE_IOERR \| (12<<8))
#define	SQLITE_IOERR_ACCESS (SQLITE_IOERR \| (13<<8))
#define	SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR \| (14<<8))
#define	SQLITE_IOERR_LOCK (SQLITE_IOERR \| (15<<8))
#define	SQLITE_IOERR_CLOSE (SQLITE_IOERR \| (16<<8))
#define	SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR \| (17<<8))
#define	SQLITE_IOERR_SHMOPEN (SQLITE_IOERR \| (18<<8))
#define	SQLITE_IOERR_SHMSIZE (SQLITE_IOERR \| (19<<8))
#define	SQLITE_IOERR_SHMLOCK (SQLITE_IOERR \| (20<<8))
#define	SQLITE_IOERR_SHMMAP (SQLITE_IOERR \| (21<<8))
#define	SQLITE_IOERR_SEEK (SQLITE_IOERR \| (22<<8))
#define	SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR \| (23<<8))
#define	SQLITE_IOERR_MMAP (SQLITE_IOERR \| (24<<8))
#define	SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR \| (25<<8))
#define	SQLITE_IOERR_CONVPATH (SQLITE_IOERR \| (26<<8))
#define	SQLITE_IOERR_VNODE (SQLITE_IOERR \| (27<<8))
#define	SQLITE_IOERR_AUTH (SQLITE_IOERR \| (28<<8))
#define	SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR \| (29<<8))
#define	SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR \| (30<<8))
#define	SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR \| (31<<8))
#define	SQLITE_IOERR_DATA (SQLITE_IOERR \| (32<<8))
#define	SQLITE_IOERR_CORRUPTFS (SQLITE_IOERR \| (33<<8))
#define	SQLITE_IOERR_IN_PAGE (SQLITE_IOERR \| (34<<8))
#define	SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED \| (1<<8))
#define	SQLITE_LOCKED_VTAB (SQLITE_LOCKED \| (2<<8))
#define	SQLITE_BUSY_RECOVERY (SQLITE_BUSY \| (1<<8))
#define	SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY \| (2<<8))
#define	SQLITE_BUSY_TIMEOUT (SQLITE_BUSY \| (3<<8))
#define	SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN \| (1<<8))
#define	SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN \| (2<<8))
#define	SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN \| (3<<8))
#define	SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN \| (4<<8))
#define	SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN \| (5<<8)) /* Not Used */
#define	SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN \| (6<<8))
#define	SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT \| (1<<8))
#define	SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT \| (2<<8))
#define	SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT \| (3<<8))
#define	SQLITE_READONLY_RECOVERY (SQLITE_READONLY \| (1<<8))
#define	SQLITE_READONLY_CANTLOCK (SQLITE_READONLY \| (2<<8))
#define	SQLITE_READONLY_ROLLBACK (SQLITE_READONLY \| (3<<8))
#define	SQLITE_READONLY_DBMOVED (SQLITE_READONLY \| (4<<8))
#define	SQLITE_READONLY_CANTINIT (SQLITE_READONLY \| (5<<8))
#define	SQLITE_READONLY_DIRECTORY (SQLITE_READONLY \| (6<<8))
#define	SQLITE_ABORT_ROLLBACK (SQLITE_ABORT \| (2<<8))
#define	SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT \| (1<<8))
#define	SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT \| (2<<8))
#define	SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT \| (3<<8))
#define	SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT \| (4<<8))
#define	SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT \| (5<<8))
#define	SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT \| (6<<8))
#define	SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT \| (7<<8))
#define	SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT \| (8<<8))
#define	SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT \| (9<<8))
#define	SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT \|(10<<8))
#define	SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT \|(11<<8))
#define	SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT \|(12<<8))
#define	SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))
#define	SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<8))
#define	SQLITE_NOTICE_RBU (SQLITE_NOTICE \| (3<<8))
#define	SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING \| (1<<8))
#define	SQLITE_AUTH_USER (SQLITE_AUTH \| (1<<8))
#define	SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK \| (1<<8))
#define	SQLITE_OK_SYMLINK (SQLITE_OK \| (2<<8)) /* internal use only */
#define	SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */
#define	SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */
#define	SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */
#define	SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */
#define	SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */
#define	SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */
#define	SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */
#define	SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */
#define	SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */
#define	SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */
#define	SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_WAL 0x00080000 /* VFS only */
#define	SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */
#define	SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */
#define	SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
#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
#define	SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800
#define	SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000
#define	SQLITE_IOCAP_IMMUTABLE 0x00002000
#define	SQLITE_IOCAP_BATCH_ATOMIC 0x00004000
#define	SQLITE_IOCAP_SUBPAGE_READ 0x00008000
#define	SQLITE_LOCK_NONE 0 /* xUnlock() only */
#define	SQLITE_LOCK_SHARED 1 /* xLock() or xUnlock() */
#define	SQLITE_LOCK_RESERVED 2 /* xLock() only */
#define	SQLITE_LOCK_PENDING 3 /* xLock() only */
#define	SQLITE_LOCK_EXCLUSIVE 4 /* xLock() only */
#define	SQLITE_SYNC_NORMAL 0x00002
#define	SQLITE_SYNC_FULL 0x00003
#define	SQLITE_SYNC_DATAONLY 0x00010
#define	SQLITE_FCNTL_LOCKSTATE 1
#define	SQLITE_FCNTL_GET_LOCKPROXYFILE 2
#define	SQLITE_FCNTL_SET_LOCKPROXYFILE 3
#define	SQLITE_FCNTL_LAST_ERRNO 4
#define	SQLITE_FCNTL_SIZE_HINT 5
#define	SQLITE_FCNTL_CHUNK_SIZE 6
#define	SQLITE_FCNTL_FILE_POINTER 7
#define	SQLITE_FCNTL_SYNC_OMITTED 8
#define	SQLITE_FCNTL_WIN32_AV_RETRY 9
#define	SQLITE_FCNTL_PERSIST_WAL 10
#define	SQLITE_FCNTL_OVERWRITE 11
#define	SQLITE_FCNTL_VFSNAME 12
#define	SQLITE_FCNTL_POWERSAFE_OVERWRITE 13
#define	SQLITE_FCNTL_PRAGMA 14
#define	SQLITE_FCNTL_BUSYHANDLER 15
#define	SQLITE_FCNTL_TEMPFILENAME 16
#define	SQLITE_FCNTL_MMAP_SIZE 18
#define	SQLITE_FCNTL_TRACE 19
#define	SQLITE_FCNTL_HAS_MOVED 20
#define	SQLITE_FCNTL_SYNC 21
#define	SQLITE_FCNTL_COMMIT_PHASETWO 22
#define	SQLITE_FCNTL_WIN32_SET_HANDLE 23
#define	SQLITE_FCNTL_WAL_BLOCK 24
#define	SQLITE_FCNTL_ZIPVFS 25
#define	SQLITE_FCNTL_RBU 26
#define	SQLITE_FCNTL_VFS_POINTER 27
#define	SQLITE_FCNTL_JOURNAL_POINTER 28
#define	SQLITE_FCNTL_WIN32_GET_HANDLE 29
#define	SQLITE_FCNTL_PDB 30
#define	SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31
#define	SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32
#define	SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33
#define	SQLITE_FCNTL_LOCK_TIMEOUT 34
#define	SQLITE_FCNTL_DATA_VERSION 35
#define	SQLITE_FCNTL_SIZE_LIMIT 36
#define	SQLITE_FCNTL_CKPT_DONE 37
#define	SQLITE_FCNTL_RESERVE_BYTES 38
#define	SQLITE_FCNTL_CKPT_START 39
#define	SQLITE_FCNTL_EXTERNAL_READER 40
#define	SQLITE_FCNTL_CKSM_FILE 41
#define	SQLITE_FCNTL_RESET_CACHE 42
#define	SQLITE_FCNTL_NULL_IO 43
#define	SQLITE_FCNTL_BLOCK_ON_CONNECT 44
#define	SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE
#define	SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE
#define	SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO
#define	SQLITE_ACCESS_EXISTS 0
#define	SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
#define	SQLITE_ACCESS_READ 2 /* Unused */
#define	SQLITE_SHM_UNLOCK 1
#define	SQLITE_SHM_LOCK 2
#define	SQLITE_SHM_SHARED 4
#define	SQLITE_SHM_EXCLUSIVE 8
#define	SQLITE_SHM_NLOCK 8
#define	SQLITE_CONFIG_SINGLETHREAD 1 /* nil */
#define	SQLITE_CONFIG_MULTITHREAD 2 /* nil */
#define	SQLITE_CONFIG_SERIALIZED 3 /* nil */
#define	SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */
#define	SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */
#define	SQLITE_CONFIG_SCRATCH 6 /* No longer used */
#define	SQLITE_CONFIG_PAGECACHE 7 /* void, int sz, int N /
#define	SQLITE_CONFIG_HEAP 8 /* void, int nByte, int min /
#define	SQLITE_CONFIG_MEMSTATUS 9 /* boolean */
#define	SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */
#define	SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */
#define	SQLITE_CONFIG_LOOKASIDE 13 /* int int */
#define	SQLITE_CONFIG_PCACHE 14 /* no-op */
#define	SQLITE_CONFIG_GETPCACHE 15 /* no-op */
#define	SQLITE_CONFIG_LOG 16 /* xFunc, void* */
#define	SQLITE_CONFIG_URI 17 /* int */
#define	SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */
#define	SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */
#define	SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */
#define	SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */
#define	SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */
#define	SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */
#define	SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int psz /
#define	SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */
#define	SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */
#define	SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */
#define	SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */
#define	SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */
#define	SQLITE_CONFIG_ROWID_IN_VIEW 30 /* int* */
#define	SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */
#define	SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */
#define	SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */
#define	SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */
#define	SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */
#define	SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */
#define	SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */
#define	SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */
#define	SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */
#define	SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */
#define	SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */
#define	SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */
#define	SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */
#define	SQLITE_DBCONFIG_STMT_SCANSTATUS 1018 /* int int* */
#define	SQLITE_DBCONFIG_REVERSE_SCANORDER 1019 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE 1020 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE 1021 /* int int* */
#define	SQLITE_DBCONFIG_ENABLE_COMMENTS 1022 /* int int* */
#define	SQLITE_DBCONFIG_MAX 1022 /* Largest DBCONFIG */
#define	SQLITE_SETLK_BLOCK_ON_CONNECT 0x01
#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 */
#define	SQLITE_CREATE_INDEX 1 /* Index Name Table Name */
#define	SQLITE_CREATE_TABLE 2 /* Table Name NULL */
#define	SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */
#define	SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */
#define	SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */
#define	SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */
#define	SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */
#define	SQLITE_CREATE_VIEW 8 /* View Name NULL */
#define	SQLITE_DELETE 9 /* Table Name NULL */
#define	SQLITE_DROP_INDEX 10 /* Index Name Table Name */
#define	SQLITE_DROP_TABLE 11 /* Table Name NULL */
#define	SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */
#define	SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */
#define	SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */
#define	SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */
#define	SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */
#define	SQLITE_DROP_VIEW 17 /* View Name NULL */
#define	SQLITE_INSERT 18 /* Table Name NULL */
#define	SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */
#define	SQLITE_READ 20 /* Table Name Column Name */
#define	SQLITE_SELECT 21 /* NULL NULL */
#define	SQLITE_TRANSACTION 22 /* Operation NULL */
#define	SQLITE_UPDATE 23 /* Table Name Column Name */
#define	SQLITE_ATTACH 24 /* Filename NULL */
#define	SQLITE_DETACH 25 /* Database Name NULL */
#define	SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
#define	SQLITE_REINDEX 27 /* Index Name NULL */
#define	SQLITE_ANALYZE 28 /* Table Name NULL */
#define	SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */
#define	SQLITE_DROP_VTABLE 30 /* Table Name Module Name */
#define	SQLITE_FUNCTION 31 /* NULL Function Name */
#define	SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */
#define	SQLITE_COPY 0 /* No longer used */
#define	SQLITE_RECURSIVE 33 /* NULL NULL */
#define	SQLITE_TRACE_STMT 0x01
#define	SQLITE_TRACE_PROFILE 0x02
#define	SQLITE_TRACE_ROW 0x04
#define	SQLITE_TRACE_CLOSE 0x08
#define	SQLITE_LIMIT_LENGTH 0
#define	SQLITE_LIMIT_SQL_LENGTH 1
#define	SQLITE_LIMIT_COLUMN 2
#define	SQLITE_LIMIT_EXPR_DEPTH 3
#define	SQLITE_LIMIT_COMPOUND_SELECT 4
#define	SQLITE_LIMIT_VDBE_OP 5
#define	SQLITE_LIMIT_FUNCTION_ARG 6
#define	SQLITE_LIMIT_ATTACHED 7
#define	SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
#define	SQLITE_LIMIT_VARIABLE_NUMBER 9
#define	SQLITE_LIMIT_TRIGGER_DEPTH 10
#define	SQLITE_LIMIT_WORKER_THREADS 11
#define	SQLITE_PREPARE_PERSISTENT 0x01
#define	SQLITE_PREPARE_NORMALIZE 0x02
#define	SQLITE_PREPARE_NO_VTAB 0x04
#define	SQLITE_PREPARE_DONT_LOG 0x10
#define	SQLITE_INTEGER 1
#define	SQLITE_FLOAT 2
#define	SQLITE_BLOB 4
#define	SQLITE_NULL 5
#define	SQLITE_TEXT 3
#define	SQLITE3_TEXT 3
#define	SQLITE_UTF8 1 /* IMP: R-37514-35566 */
#define	SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */
#define	SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */
#define	SQLITE_UTF16 4 /* Use native byte order */
#define	SQLITE_ANY 5 /* Deprecated */
#define	SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */
#define	SQLITE_DETERMINISTIC 0x000000800
#define	SQLITE_DIRECTONLY 0x000080000
#define	SQLITE_SUBTYPE 0x000100000
#define	SQLITE_INNOCUOUS 0x000200000
#define	SQLITE_RESULT_SUBTYPE 0x001000000
#define	SQLITE_SELFORDER1 0x002000000
#define	SQLITE_STATIC ((sqlite3_destructor_type)0)
#define	SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
#define	SQLITE_WIN32_DATA_DIRECTORY_TYPE 1
#define	SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2
#define	SQLITE_TXN_NONE 0
#define	SQLITE_TXN_READ 1
#define	SQLITE_TXN_WRITE 2
#define	SQLITE_INDEX_SCAN_UNIQUE 0x00000001 /* Scan visits at most 1 row */
#define	SQLITE_INDEX_SCAN_HEX 0x00000002 /* Display idxNum as hex */
#define	SQLITE_INDEX_CONSTRAINT_EQ 2
#define	SQLITE_INDEX_CONSTRAINT_GT 4
#define	SQLITE_INDEX_CONSTRAINT_LE 8
#define	SQLITE_INDEX_CONSTRAINT_LT 16
#define	SQLITE_INDEX_CONSTRAINT_GE 32
#define	SQLITE_INDEX_CONSTRAINT_MATCH 64
#define	SQLITE_INDEX_CONSTRAINT_LIKE 65
#define	SQLITE_INDEX_CONSTRAINT_GLOB 66
#define	SQLITE_INDEX_CONSTRAINT_REGEXP 67
#define	SQLITE_INDEX_CONSTRAINT_NE 68
#define	SQLITE_INDEX_CONSTRAINT_ISNOT 69
#define	SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70
#define	SQLITE_INDEX_CONSTRAINT_ISNULL 71
#define	SQLITE_INDEX_CONSTRAINT_IS 72
#define	SQLITE_INDEX_CONSTRAINT_LIMIT 73
#define	SQLITE_INDEX_CONSTRAINT_OFFSET 74
#define	SQLITE_INDEX_CONSTRAINT_FUNCTION 150
#define	SQLITE_MUTEX_FAST 0
#define	SQLITE_MUTEX_RECURSIVE 1
#define	SQLITE_MUTEX_STATIC_MAIN 2
#define	SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */
#define	SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */
#define	SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */
#define	SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */
#define	SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */
#define	SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */
#define	SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */
#define	SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */
#define	SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */
#define	SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */
#define	SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */
#define	SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */
#define	SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */
#define	SQLITE_MUTEX_STATIC_MASTER 2
#define	SQLITE_TESTCTRL_FIRST 5
#define	SQLITE_TESTCTRL_PRNG_SAVE 5
#define	SQLITE_TESTCTRL_PRNG_RESTORE 6
#define	SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */
#define	SQLITE_TESTCTRL_FK_NO_ACTION 7
#define	SQLITE_TESTCTRL_BITVEC_TEST 8
#define	SQLITE_TESTCTRL_FAULT_INSTALL 9
#define	SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10
#define	SQLITE_TESTCTRL_PENDING_BYTE 11
#define	SQLITE_TESTCTRL_ASSERT 12
#define	SQLITE_TESTCTRL_ALWAYS 13
#define	SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */
#define	SQLITE_TESTCTRL_JSON_SELFCHECK 14
#define	SQLITE_TESTCTRL_OPTIMIZATIONS 15
#define	SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */
#define	SQLITE_TESTCTRL_GETOPT 16
#define	SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */
#define	SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17
#define	SQLITE_TESTCTRL_LOCALTIME_FAULT 18
#define	SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */
#define	SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19
#define	SQLITE_TESTCTRL_NEVER_CORRUPT 20
#define	SQLITE_TESTCTRL_VDBE_COVERAGE 21
#define	SQLITE_TESTCTRL_BYTEORDER 22
#define	SQLITE_TESTCTRL_ISINIT 23
#define	SQLITE_TESTCTRL_SORTER_MMAP 24
#define	SQLITE_TESTCTRL_IMPOSTER 25
#define	SQLITE_TESTCTRL_PARSER_COVERAGE 26
#define	SQLITE_TESTCTRL_RESULT_INTREAL 27
#define	SQLITE_TESTCTRL_PRNG_SEED 28
#define	SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29
#define	SQLITE_TESTCTRL_SEEK_COUNT 30
#define	SQLITE_TESTCTRL_TRACEFLAGS 31
#define	SQLITE_TESTCTRL_TUNE 32
#define	SQLITE_TESTCTRL_LOGEST 33
#define	SQLITE_TESTCTRL_USELONGDOUBLE 34 /* NOT USED */
#define	SQLITE_TESTCTRL_LAST 34 /* Largest TESTCTRL */
#define	SQLITE_STATUS_MEMORY_USED 0
#define	SQLITE_STATUS_PAGECACHE_USED 1
#define	SQLITE_STATUS_PAGECACHE_OVERFLOW 2
#define	SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */
#define	SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */
#define	SQLITE_STATUS_MALLOC_SIZE 5
#define	SQLITE_STATUS_PARSER_STACK 6
#define	SQLITE_STATUS_PAGECACHE_SIZE 7
#define	SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */
#define	SQLITE_STATUS_MALLOC_COUNT 9
#define	SQLITE_DBSTATUS_LOOKASIDE_USED 0
#define	SQLITE_DBSTATUS_CACHE_USED 1
#define	SQLITE_DBSTATUS_SCHEMA_USED 2
#define	SQLITE_DBSTATUS_STMT_USED 3
#define	SQLITE_DBSTATUS_LOOKASIDE_HIT 4
#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5
#define	SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6
#define	SQLITE_DBSTATUS_CACHE_HIT 7
#define	SQLITE_DBSTATUS_CACHE_MISS 8
#define	SQLITE_DBSTATUS_CACHE_WRITE 9
#define	SQLITE_DBSTATUS_DEFERRED_FKS 10
#define	SQLITE_DBSTATUS_CACHE_USED_SHARED 11
#define	SQLITE_DBSTATUS_CACHE_SPILL 12
#define	SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */
#define	SQLITE_STMTSTATUS_FULLSCAN_STEP 1
#define	SQLITE_STMTSTATUS_SORT 2
#define	SQLITE_STMTSTATUS_AUTOINDEX 3
#define	SQLITE_STMTSTATUS_VM_STEP 4
#define	SQLITE_STMTSTATUS_REPREPARE 5
#define	SQLITE_STMTSTATUS_RUN 6
#define	SQLITE_STMTSTATUS_FILTER_MISS 7
#define	SQLITE_STMTSTATUS_FILTER_HIT 8
#define	SQLITE_STMTSTATUS_MEMUSED 99
#define	SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */
#define	SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */
#define	SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for readers */
#define	SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */
#define	SQLITE_VTAB_CONSTRAINT_SUPPORT 1
#define	SQLITE_VTAB_INNOCUOUS 2
#define	SQLITE_VTAB_DIRECTONLY 3
#define	SQLITE_VTAB_USES_ALL_SCHEMAS 4
#define	SQLITE_ROLLBACK 1
#define	SQLITE_FAIL 3
#define	SQLITE_REPLACE 5
#define	SQLITE_SCANSTAT_NLOOP 0
#define	SQLITE_SCANSTAT_NVISIT 1
#define	SQLITE_SCANSTAT_EST 2
#define	SQLITE_SCANSTAT_NAME 3
#define	SQLITE_SCANSTAT_EXPLAIN 4
#define	SQLITE_SCANSTAT_SELECTID 5
#define	SQLITE_SCANSTAT_PARENTID 6
#define	SQLITE_SCANSTAT_NCYCLE 7
#define	SQLITE_SCANSTAT_COMPLEX 0x0001
#define	SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */
#define	SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */
#define	SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */
#define	SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */
#define	_SQLITE3RTREE_H_
#define	NOT_WITHIN 0 /* Object completely outside of query region */
#define	PARTLY_WITHIN 1 /* Object partially overlaps query region */
#define	FULLY_WITHIN 2 /* Object fully contained within query region */
#define	_FTS5_H
#define	FTS5_TOKENIZE_QUERY 0x0001
#define	FTS5_TOKENIZE_PREFIX 0x0002
#define	FTS5_TOKENIZE_DOCUMENT 0x0004
#define	FTS5_TOKENIZE_AUX 0x0008
#define	FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */

Typedefs
typedef int(*	sqlite3_callback) (void , int, char , char *)
typedef const char *	sqlite3_filename
typedef void(*	sqlite3_syscall_ptr) (void)
typedef void(*	sqlite3_destructor_type) (void *)
typedef struct sqlite3_snapshot	sqlite3_snapshot
typedef void(*	fts5_extension_function) (const Fts5ExtensionApi pApi, Fts5Context pFts, sqlite3_context pCtx, int nVal, sqlite3_value *apVal)

Functions
const char *	sqlite3_libversion (void)
const char *	sqlite3_sourceid (void)
int	sqlite3_libversion_number (void)
int	sqlite3_compileoption_used (const char *zOptName)
const char *	sqlite3_compileoption_get (int N)
int	sqlite3_threadsafe (void)
int	sqlite3_close (sqlite3 *)
int	sqlite3_close_v2 (sqlite3 *)
int	sqlite3_exec (sqlite3 , const char sql, int(callback)(void , int, char , char ), void , char *errmsg)
int	sqlite3_initialize (void)
int	sqlite3_shutdown (void)
int	sqlite3_os_init (void)
int	sqlite3_os_end (void)
int	sqlite3_config (int,...)
int	sqlite3_db_config (sqlite3 *, int op,...)
int	sqlite3_extended_result_codes (sqlite3 *, int onoff)
sqlite3_int64	sqlite3_last_insert_rowid (sqlite3 *)
void	sqlite3_set_last_insert_rowid (sqlite3 *, sqlite3_int64)
int	sqlite3_changes (sqlite3 *)
sqlite3_int64	sqlite3_changes64 (sqlite3 *)
int	sqlite3_total_changes (sqlite3 *)
sqlite3_int64	sqlite3_total_changes64 (sqlite3 *)
void	sqlite3_interrupt (sqlite3 *)
int	sqlite3_is_interrupted (sqlite3 *)
int	sqlite3_complete (const char *sql)
int	sqlite3_complete16 (const void *sql)
int	sqlite3_busy_handler (sqlite3 , int()(void , int), void )
int	sqlite3_busy_timeout (sqlite3 *, int ms)
int	sqlite3_setlk_timeout (sqlite3 *, int ms, int flags)
int	sqlite3_get_table (sqlite3 db, const char zSql, char **pazResult, int pnRow, int pnColumn, char *pzErrmsg)
void	sqlite3_free_table (char **result)
char *	sqlite3_mprintf (const char *,...)
char *	sqlite3_vmprintf (const char *, va_list)
char *	sqlite3_snprintf (int, char , const char ,...)
char *	sqlite3_vsnprintf (int, char , const char , va_list)
void *	sqlite3_malloc (int)
void *	sqlite3_malloc64 (sqlite3_uint64)
void *	sqlite3_realloc (void *, int)
void *	sqlite3_realloc64 (void *, sqlite3_uint64)
void	sqlite3_free (void *)
sqlite3_uint64	sqlite3_msize (void *)
sqlite3_int64	sqlite3_memory_used (void)
sqlite3_int64	sqlite3_memory_highwater (int resetFlag)
void	sqlite3_randomness (int N, void *P)
int	sqlite3_set_authorizer (sqlite3 , int(xAuth)(void , int, const char , const char , const char , const char ), void pUserData)
void *	sqlite3_trace (sqlite3 , void(xTrace)(void , const char ), void *)
void *	sqlite3_profile (sqlite3 , void(xProfile)(void , const char , sqlite3_uint64), void *)
int	sqlite3_trace_v2 (sqlite3 , unsigned uMask, int(xCallback)(unsigned, void , void , void ), void pCtx)
void	sqlite3_progress_handler (sqlite3 , int, int()(void ), void )
int	sqlite3_open (const char filename, sqlite3 *ppDb)
int	sqlite3_open16 (const void filename, sqlite3 *ppDb)
int	sqlite3_open_v2 (const char filename, sqlite3 ppDb, int flags, const char zVfs)
const char *	sqlite3_uri_parameter (sqlite3_filename z, const char *zParam)
int	sqlite3_uri_boolean (sqlite3_filename z, const char *zParam, int bDefault)
sqlite3_int64	sqlite3_uri_int64 (sqlite3_filename, const char *, sqlite3_int64)
const char *	sqlite3_uri_key (sqlite3_filename z, int N)
const char *	sqlite3_filename_database (sqlite3_filename)
const char *	sqlite3_filename_journal (sqlite3_filename)
const char *	sqlite3_filename_wal (sqlite3_filename)
sqlite3_file *	sqlite3_database_file_object (const char *)
sqlite3_filename	sqlite3_create_filename (const char zDatabase, const char zJournal, const char zWal, int nParam, const char *azParam)
void	sqlite3_free_filename (sqlite3_filename)
int	sqlite3_errcode (sqlite3 *db)
int	sqlite3_extended_errcode (sqlite3 *db)
const char *	sqlite3_errmsg (sqlite3 *)
const void *	sqlite3_errmsg16 (sqlite3 *)
const char *	sqlite3_errstr (int)
int	sqlite3_error_offset (sqlite3 *db)
int	sqlite3_limit (sqlite3 *, int id, int newVal)
int	sqlite3_prepare (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)
int	sqlite3_prepare_v2 (sqlite3 db, const char zSql, int nByte, sqlite3_stmt ppStmt, const char pzTail)
int	sqlite3_prepare_v3 (sqlite3 db, const char zSql, int nByte, unsigned int prepFlags, sqlite3_stmt ppStmt, const char pzTail)
int	sqlite3_prepare16 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)
int	sqlite3_prepare16_v2 (sqlite3 db, const void zSql, int nByte, sqlite3_stmt ppStmt, const void pzTail)
int	sqlite3_prepare16_v3 (sqlite3 db, const void zSql, int nByte, unsigned int prepFlags, sqlite3_stmt ppStmt, const void pzTail)
const char *	sqlite3_sql (sqlite3_stmt *pStmt)
char *	sqlite3_expanded_sql (sqlite3_stmt *pStmt)
int	sqlite3_stmt_readonly (sqlite3_stmt *pStmt)
int	sqlite3_stmt_isexplain (sqlite3_stmt *pStmt)
int	sqlite3_stmt_explain (sqlite3_stmt *pStmt, int eMode)
int	sqlite3_stmt_busy (sqlite3_stmt *)
int	sqlite3_bind_blob (sqlite3_stmt , int, const void , int n, void()(void ))
int	sqlite3_bind_blob64 (sqlite3_stmt , int, const void , sqlite3_uint64, 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, void()(void ))
int	sqlite3_bind_text16 (sqlite3_stmt , int, const void , int, void()(void ))
int	sqlite3_bind_text64 (sqlite3_stmt , int, const char , sqlite3_uint64, void()(void ), unsigned char encoding)
int	sqlite3_bind_value (sqlite3_stmt , int, const sqlite3_value )
int	sqlite3_bind_pointer (sqlite3_stmt , int, void , const char , void()(void *))
int	sqlite3_bind_zeroblob (sqlite3_stmt *, int, int n)
int	sqlite3_bind_zeroblob64 (sqlite3_stmt *, int, sqlite3_uint64)
int	sqlite3_bind_parameter_count (sqlite3_stmt *)
const char *	sqlite3_bind_parameter_name (sqlite3_stmt *, int)
int	sqlite3_bind_parameter_index (sqlite3_stmt , const char zName)
int	sqlite3_clear_bindings (sqlite3_stmt *)
int	sqlite3_column_count (sqlite3_stmt *pStmt)
const char *	sqlite3_column_name (sqlite3_stmt *, int N)
const void *	sqlite3_column_name16 (sqlite3_stmt *, int N)
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)
const char *	sqlite3_column_decltype (sqlite3_stmt *, int)
const void *	sqlite3_column_decltype16 (sqlite3_stmt *, int)
int	sqlite3_step (sqlite3_stmt *)
int	sqlite3_data_count (sqlite3_stmt *pStmt)
const void *	sqlite3_column_blob (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)
sqlite3_value *	sqlite3_column_value (sqlite3_stmt *, int iCol)
int	sqlite3_column_bytes (sqlite3_stmt *, int iCol)
int	sqlite3_column_bytes16 (sqlite3_stmt *, int iCol)
int	sqlite3_column_type (sqlite3_stmt *, int iCol)
int	sqlite3_finalize (sqlite3_stmt *pStmt)
int	sqlite3_reset (sqlite3_stmt *pStmt)
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 *))
int	sqlite3_create_function_v2 (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 ), void(xDestroy)(void *))
int	sqlite3_create_window_function (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context ), void(xValue)(sqlite3_context ), void(xInverse)(sqlite3_context , int, sqlite3_value ), void(xDestroy)(void *))
int	sqlite3_aggregate_count (sqlite3_context *)
int	sqlite3_expired (sqlite3_stmt *)
int	sqlite3_transfer_bindings (sqlite3_stmt , sqlite3_stmt )
int	sqlite3_global_recover (void)
void	sqlite3_thread_cleanup (void)
int	sqlite3_memory_alarm (void()(void , sqlite3_int64, int), void *, sqlite3_int64)
const void *	sqlite3_value_blob (sqlite3_value *)
double	sqlite3_value_double (sqlite3_value *)
int	sqlite3_value_int (sqlite3_value *)
sqlite3_int64	sqlite3_value_int64 (sqlite3_value *)
void *	sqlite3_value_pointer (sqlite3_value , const char )
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_bytes (sqlite3_value *)
int	sqlite3_value_bytes16 (sqlite3_value *)
int	sqlite3_value_type (sqlite3_value *)
int	sqlite3_value_numeric_type (sqlite3_value *)
int	sqlite3_value_nochange (sqlite3_value *)
int	sqlite3_value_frombind (sqlite3_value *)
int	sqlite3_value_encoding (sqlite3_value *)
unsigned int	sqlite3_value_subtype (sqlite3_value *)
sqlite3_value *	sqlite3_value_dup (const sqlite3_value *)
void	sqlite3_value_free (sqlite3_value *)
void *	sqlite3_aggregate_context (sqlite3_context *, int nBytes)
void *	sqlite3_user_data (sqlite3_context *)
sqlite3 *	sqlite3_context_db_handle (sqlite3_context *)
void *	sqlite3_get_auxdata (sqlite3_context *, int N)
void	sqlite3_set_auxdata (sqlite3_context , int N, void , void()(void ))
void *	sqlite3_get_clientdata (sqlite3 , const char )
int	sqlite3_set_clientdata (sqlite3 , const char , void , void()(void *))
void	sqlite3_result_blob (sqlite3_context , const void , int, void()(void ))
void	sqlite3_result_blob64 (sqlite3_context , const void , sqlite3_uint64, 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_text64 (sqlite3_context , const char , sqlite3_uint64, void()(void ), unsigned char encoding)
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_pointer (sqlite3_context , void , const char , void()(void *))
void	sqlite3_result_zeroblob (sqlite3_context *, int n)
int	sqlite3_result_zeroblob64 (sqlite3_context *, sqlite3_uint64 n)
void	sqlite3_result_subtype (sqlite3_context *, unsigned int)
int	sqlite3_create_collation (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))
int	sqlite3_create_collation_v2 (sqlite3 , const char zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void ), void(xDestroy)(void *))
int	sqlite3_create_collation16 (sqlite3 , const void zName, int eTextRep, void pArg, int(xCompare)(void , int, const void , int, const void *))
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 ))
int	sqlite3_sleep (int)
int	sqlite3_win32_set_directory (unsigned long type, void *zValue)
int	sqlite3_win32_set_directory8 (unsigned long type, const char *zValue)
int	sqlite3_win32_set_directory16 (unsigned long type, const void *zValue)
int	sqlite3_get_autocommit (sqlite3 *)
sqlite3 *	sqlite3_db_handle (sqlite3_stmt *)
const char *	sqlite3_db_name (sqlite3 *db, int N)
sqlite3_filename	sqlite3_db_filename (sqlite3 db, const char zDbName)
int	sqlite3_db_readonly (sqlite3 db, const char zDbName)
int	sqlite3_txn_state (sqlite3 , const char zSchema)
sqlite3_stmt *	sqlite3_next_stmt (sqlite3 pDb, sqlite3_stmt pStmt)
void *	sqlite3_commit_hook (sqlite3 , int()(void ), void )
void *	sqlite3_rollback_hook (sqlite3 , void()(void ), void )
int	sqlite3_autovacuum_pages (sqlite3 db, unsigned int()(void , const char , unsigned int, unsigned int, unsigned int), void , void()(void *))
void *	sqlite3_update_hook (sqlite3 , void()(void , int, char const , char const , sqlite3_int64), void )
int	sqlite3_enable_shared_cache (int)
int	sqlite3_release_memory (int)
int	sqlite3_db_release_memory (sqlite3 *)
sqlite3_int64	sqlite3_soft_heap_limit64 (sqlite3_int64 N)
sqlite3_int64	sqlite3_hard_heap_limit64 (sqlite3_int64 N)
void	sqlite3_soft_heap_limit (int N)
int	sqlite3_table_column_metadata (sqlite3 db, const char zDbName, const char zTableName, const char zColumnName, char const pzDataType, char const pzCollSeq, int pNotNull, int pPrimaryKey, int *pAutoinc)
int	sqlite3_load_extension (sqlite3 db, const char zFile, const char zProc, char *pzErrMsg)
int	sqlite3_enable_load_extension (sqlite3 *db, int onoff)
int	sqlite3_auto_extension (void(*xEntryPoint)(void))
int	sqlite3_cancel_auto_extension (void(*xEntryPoint)(void))
void	sqlite3_reset_auto_extension (void)
int	sqlite3_create_module (sqlite3 db, const char zName, const sqlite3_module p, void pClientData)
int	sqlite3_create_module_v2 (sqlite3 db, const char zName, const sqlite3_module p, void pClientData, void(xDestroy)(void ))
int	sqlite3_drop_modules (sqlite3 db, const char *azKeep)
int	sqlite3_declare_vtab (sqlite3 , const char zSQL)
int	sqlite3_overload_function (sqlite3 , const char zFuncName, int nArg)
int	sqlite3_blob_open (sqlite3 , const char zDb, const char zTable, const char zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob)
int	sqlite3_blob_reopen (sqlite3_blob *, sqlite3_int64)
int	sqlite3_blob_close (sqlite3_blob *)
int	sqlite3_blob_bytes (sqlite3_blob *)
int	sqlite3_blob_read (sqlite3_blob , void Z, int N, int iOffset)
int	sqlite3_blob_write (sqlite3_blob , const void z, int n, int iOffset)
sqlite3_vfs *	sqlite3_vfs_find (const char *zVfsName)
int	sqlite3_vfs_register (sqlite3_vfs *, int makeDflt)
int	sqlite3_vfs_unregister (sqlite3_vfs *)
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 *)
int	sqlite3_mutex_held (sqlite3_mutex *)
int	sqlite3_mutex_notheld (sqlite3_mutex *)
sqlite3_mutex *	sqlite3_db_mutex (sqlite3 *)
int	sqlite3_file_control (sqlite3 , const char zDbName, int op, void *)
int	sqlite3_test_control (int op,...)
int	sqlite3_keyword_count (void)
int	sqlite3_keyword_name (int, const char *, int )
int	sqlite3_keyword_check (const char *, int)
sqlite3_str *	sqlite3_str_new (sqlite3 *)
char *	sqlite3_str_finish (sqlite3_str *)
void	sqlite3_str_appendf (sqlite3_str , const char zFormat,...)
void	sqlite3_str_vappendf (sqlite3_str , const char zFormat, va_list)
void	sqlite3_str_append (sqlite3_str , const char zIn, int N)
void	sqlite3_str_appendall (sqlite3_str , const char zIn)
void	sqlite3_str_appendchar (sqlite3_str *, int N, char C)
void	sqlite3_str_reset (sqlite3_str *)
int	sqlite3_str_errcode (sqlite3_str *)
int	sqlite3_str_length (sqlite3_str *)
char *	sqlite3_str_value (sqlite3_str *)
int	sqlite3_status (int op, int pCurrent, int pHighwater, int resetFlag)
int	sqlite3_status64 (int op, sqlite3_int64 pCurrent, sqlite3_int64 pHighwater, int resetFlag)
int	sqlite3_db_status (sqlite3 , int op, int pCur, int *pHiwtr, int resetFlg)
int	sqlite3_stmt_status (sqlite3_stmt *, int op, int resetFlg)
sqlite3_backup *	sqlite3_backup_init (sqlite3 pDest, const char zDestName, sqlite3 pSource, const char zSourceName)
int	sqlite3_backup_step (sqlite3_backup *p, int nPage)
int	sqlite3_backup_finish (sqlite3_backup *p)
int	sqlite3_backup_remaining (sqlite3_backup *p)
int	sqlite3_backup_pagecount (sqlite3_backup *p)
int	sqlite3_unlock_notify (sqlite3 pBlocked, void(xNotify)(void *apArg, int nArg), void pNotifyArg)
int	sqlite3_stricmp (const char , const char )
int	sqlite3_strnicmp (const char , const char , int)
int	sqlite3_strglob (const char zGlob, const char zStr)
int	sqlite3_strlike (const char zGlob, const char zStr, unsigned int cEsc)
void	sqlite3_log (int iErrCode, const char *zFormat,...)
void *	sqlite3_wal_hook (sqlite3 , int()(void , sqlite3 , const char , int), void )
int	sqlite3_wal_autocheckpoint (sqlite3 *db, int N)
int	sqlite3_wal_checkpoint (sqlite3 db, const char zDb)
int	sqlite3_wal_checkpoint_v2 (sqlite3 db, const char zDb, int eMode, int pnLog, int pnCkpt)
int	sqlite3_vtab_config (sqlite3 *, int op,...)
int	sqlite3_vtab_on_conflict (sqlite3 *)
int	sqlite3_vtab_nochange (sqlite3_context *)
const char *	sqlite3_vtab_collation (sqlite3_index_info *, int)
int	sqlite3_vtab_distinct (sqlite3_index_info *)
int	sqlite3_vtab_in (sqlite3_index_info *, int iCons, int bHandle)
int	sqlite3_vtab_in_first (sqlite3_value pVal, sqlite3_value *ppOut)
int	sqlite3_vtab_in_next (sqlite3_value pVal, sqlite3_value *ppOut)
int	sqlite3_vtab_rhs_value (sqlite3_index_info , int, sqlite3_value *ppVal)
int	sqlite3_stmt_scanstatus (sqlite3_stmt pStmt, int idx, int iScanStatusOp, void pOut)
int	sqlite3_stmt_scanstatus_v2 (sqlite3_stmt pStmt, int idx, int iScanStatusOp, int flags, void pOut)
void	sqlite3_stmt_scanstatus_reset (sqlite3_stmt *)
int	sqlite3_db_cacheflush (sqlite3 *)
int	sqlite3_system_errno (sqlite3 *)
int	sqlite3_snapshot_get (sqlite3 db, const char zSchema, sqlite3_snapshot **ppSnapshot)
int	sqlite3_snapshot_open (sqlite3 db, const char zSchema, sqlite3_snapshot *pSnapshot)
void	sqlite3_snapshot_free (sqlite3_snapshot *)
int	sqlite3_snapshot_cmp (sqlite3_snapshot p1, sqlite3_snapshot p2)
int	sqlite3_snapshot_recover (sqlite3 db, const char zDb)
unsigned char *	sqlite3_serialize (sqlite3 db, const char zSchema, sqlite3_int64 *piSize, unsigned int mFlags)
int	sqlite3_deserialize (sqlite3 db, const char zSchema, unsigned char *pData, sqlite3_int64 szDb, sqlite3_int64 szBuf, unsigned mFlags)
int	sqlite3_rtree_geometry_callback (sqlite3 db, const char zGeom, int(xGeom)(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int ), void *pContext)
int	sqlite3_rtree_query_callback (sqlite3 db, const char zQueryFunc, int(xQueryFunc)(sqlite3_rtree_query_info ), void pContext, void(xDestructor)(void *))

Variables
const char	sqlite3_version []
char *	sqlite3_temp_directory
char *	sqlite3_data_directory

Data Structure Documentation

◆ sqlite3_file

struct sqlite3_file

Collaboration diagram for sqlite3_file:

Data Fields
const struct sqlite3_io_methods *	pMethods

◆ sqlite3_io_methods

struct sqlite3_io_methods

Data Fields
int	iVersion
int()(sqlite3_file , int *pResOut)	xCheckReservedLock
int()(sqlite3_file )	xClose
int()(sqlite3_file )	xDeviceCharacteristics
int()(sqlite3_file , sqlite3_int64 iOfst, int iAmt, void **pp)	xFetch
int()(sqlite3_file , int op, void *pArg)	xFileControl
int()(sqlite3_file , sqlite3_int64 *pSize)	xFileSize
int()(sqlite3_file , int)	xLock
int()(sqlite3_file , void *, int iAmt, sqlite3_int64 iOfst)	xRead
int()(sqlite3_file )	xSectorSize
void()(sqlite3_file )	xShmBarrier
int()(sqlite3_file , int offset, int n, int flags)	xShmLock
int()(sqlite3_file , int iPg, int pgsz, int, void volatile **)	xShmMap
int()(sqlite3_file , int deleteFlag)	xShmUnmap
int()(sqlite3_file , int flags)	xSync
int()(sqlite3_file , sqlite3_int64 size)	xTruncate
int()(sqlite3_file , sqlite3_int64 iOfst, void *p)	xUnfetch
int()(sqlite3_file , int)	xUnlock
int()(sqlite3_file , const void *, int iAmt, sqlite3_int64 iOfst)	xWrite

◆ sqlite3_vfs

struct sqlite3_vfs

Collaboration diagram for sqlite3_vfs:

Data Fields
int	iVersion
int	mxPathname
void *	pAppData
sqlite3_vfs *	pNext
int	szOsFile
int()(sqlite3_vfs , const char zName, int flags, int pResOut)	xAccess
int()(sqlite3_vfs , double *)	xCurrentTime
int()(sqlite3_vfs , sqlite3_int64 *)	xCurrentTimeInt64
int()(sqlite3_vfs , const char *zName, int syncDir)	xDelete
void()(sqlite3_vfs , void *)	xDlClose
void()(sqlite3_vfs , int nByte, char *zErrMsg)	xDlError
void ()(sqlite3_vfs , const char zFilename)	xDlOpen
void(()(sqlite3_vfs , void , const char *zSymbol))(void)	xDlSym
int()(sqlite3_vfs , const char zName, int nOut, char zOut)	xFullPathname
int()(sqlite3_vfs , int, char *)	xGetLastError
sqlite3_syscall_ptr()(sqlite3_vfs , const char *zName)	xGetSystemCall
const char ()(sqlite3_vfs , const char zName)	xNextSystemCall
int()(sqlite3_vfs , sqlite3_filename zName, sqlite3_file , int flags, int pOutFlags)	xOpen
int()(sqlite3_vfs , int nByte, char *zOut)	xRandomness
int()(sqlite3_vfs , const char *zName, sqlite3_syscall_ptr)	xSetSystemCall
int()(sqlite3_vfs , int microseconds)	xSleep
const char *	zName

◆ sqlite3_mem_methods

struct sqlite3_mem_methods

Data Fields
void *	pAppData
void()(void )	xFree
int()(void )	xInit
void ()(int)	xMalloc
void ()(void *, int)	xRealloc
int(*)(int)	xRoundup
void()(void )	xShutdown
int()(void )	xSize

◆ sqlite3_module

struct sqlite3_module

Data Fields
int	iVersion
int()(sqlite3_vtab pVTab)	xBegin
int()(sqlite3_vtab pVTab, sqlite3_index_info *)	xBestIndex
int()(sqlite3_vtab_cursor )	xClose
int()(sqlite3_vtab_cursor , sqlite3_context *, int)	xColumn
int()(sqlite3_vtab pVTab)	xCommit
int()(sqlite3 , void pAux, int argc, const char const argv, sqlite3_vtab ppVTab, char *)	xConnect
int()(sqlite3 , void pAux, int argc, const char const argv, sqlite3_vtab ppVTab, char *)	xCreate
int()(sqlite3_vtab pVTab)	xDestroy
int()(sqlite3_vtab pVTab)	xDisconnect
int()(sqlite3_vtab_cursor )	xEof
int()(sqlite3_vtab_cursor , int idxNum, const char idxStr, int argc, sqlite3_value *argv)	xFilter
int()(sqlite3_vtab pVtab, int nArg, const char zName, void(pxFunc)(sqlite3_context , int, sqlite3_value ), void ppArg)	xFindFunction
int()(sqlite3_vtab pVTab, const char zSchema, const char zTabName, int mFlags, char **pzErr)	xIntegrity
int()(sqlite3_vtab_cursor )	xNext
int()(sqlite3_vtab pVTab, sqlite3_vtab_cursor **ppCursor)	xOpen
int()(sqlite3_vtab pVTab, int)	xRelease
int()(sqlite3_vtab pVtab, const char *zNew)	xRename
int()(sqlite3_vtab pVTab)	xRollback
int()(sqlite3_vtab pVTab, int)	xRollbackTo
int()(sqlite3_vtab_cursor , sqlite3_int64 *pRowid)	xRowid
int()(sqlite3_vtab pVTab, int)	xSavepoint
int()(const char )	xShadowName
int()(sqlite3_vtab pVTab)	xSync
int()(sqlite3_vtab , int, sqlite3_value *, sqlite3_int64 )	xUpdate

◆ sqlite3_index_info

struct sqlite3_index_info

Collaboration diagram for sqlite3_index_info:

Data Fields
struct sqlite3_index_constraint *	aConstraint
struct sqlite3_index_constraint_usage *	aConstraintUsage
struct sqlite3_index_orderby *	aOrderBy
sqlite3_uint64	colUsed
double	estimatedCost
sqlite3_int64	estimatedRows
int	idxFlags
int	idxNum
char *	idxStr
int	nConstraint
int	needToFreeIdxStr
int	nOrderBy
int	orderByConsumed

◆ sqlite3_index_info::sqlite3_index_constraint

struct sqlite3_index_info::sqlite3_index_constraint

Data Fields
int	iColumn
int	iTermOffset
unsigned char	op
unsigned char	usable

◆ sqlite3_index_info::sqlite3_index_orderby

struct sqlite3_index_info::sqlite3_index_orderby

Data Fields
unsigned char	desc
int	iColumn

◆ sqlite3_index_info::sqlite3_index_constraint_usage

struct sqlite3_index_info::sqlite3_index_constraint_usage

Data Fields
int	argvIndex
unsigned char	omit

◆ sqlite3_vtab

struct sqlite3_vtab

Collaboration diagram for sqlite3_vtab:

Data Fields
int	nRef
const sqlite3_module *	pModule
char *	zErrMsg

◆ sqlite3_vtab_cursor

struct sqlite3_vtab_cursor

Collaboration diagram for sqlite3_vtab_cursor:

Data Fields
sqlite3_vtab *	pVtab

◆ sqlite3_mutex_methods

struct sqlite3_mutex_methods

Collaboration diagram for sqlite3_mutex_methods:

Data Fields
sqlite3_mutex ()(int)	xMutexAlloc
int(*)(void)	xMutexEnd
void()(sqlite3_mutex )	xMutexEnter
void()(sqlite3_mutex )	xMutexFree
int()(sqlite3_mutex )	xMutexHeld
int(*)(void)	xMutexInit
void()(sqlite3_mutex )	xMutexLeave
int()(sqlite3_mutex )	xMutexNotheld
int()(sqlite3_mutex )	xMutexTry

◆ sqlite3_pcache_page

struct sqlite3_pcache_page

Data Fields
void *	pBuf
void *	pExtra

◆ sqlite3_pcache_methods2

struct sqlite3_pcache_methods2

Collaboration diagram for sqlite3_pcache_methods2:

Data Fields
int	iVersion
void *	pArg
void()(sqlite3_pcache , int nCachesize)	xCachesize
sqlite3_pcache ()(int szPage, int szExtra, int bPurgeable)	xCreate
void()(sqlite3_pcache )	xDestroy
sqlite3_pcache_page ()(sqlite3_pcache *, unsigned key, int createFlag)	xFetch
int()(void )	xInit
int()(sqlite3_pcache )	xPagecount
void()(sqlite3_pcache , sqlite3_pcache_page *, unsigned oldKey, unsigned newKey)	xRekey
void()(sqlite3_pcache )	xShrink
void()(void )	xShutdown
void()(sqlite3_pcache , unsigned iLimit)	xTruncate
void()(sqlite3_pcache , sqlite3_pcache_page *, int discard)	xUnpin

◆ sqlite3_pcache_methods

struct sqlite3_pcache_methods

Data Fields
void *	pArg
void()(sqlite3_pcache , int nCachesize)	xCachesize
sqlite3_pcache ()(int szPage, int bPurgeable)	xCreate
void()(sqlite3_pcache )	xDestroy
void ()(sqlite3_pcache *, unsigned key, int createFlag)	xFetch
int()(void )	xInit
int()(sqlite3_pcache )	xPagecount
void()(sqlite3_pcache , void *, unsigned oldKey, unsigned newKey)	xRekey
void()(void )	xShutdown
void()(sqlite3_pcache , unsigned iLimit)	xTruncate
void()(sqlite3_pcache , void *, int discard)	xUnpin

◆ sqlite3_snapshot

struct sqlite3_snapshot

Data Fields
unsigned char	hidden[48]

◆ sqlite3_rtree_geometry

struct sqlite3_rtree_geometry

Data Fields
sqlite3_rtree_dbl *	aParam
int	nParam
void *	pContext
void *	pUser
void()(void )	xDelUser

◆ sqlite3_rtree_query_info

struct sqlite3_rtree_query_info

Collaboration diagram for sqlite3_rtree_query_info:

Data Fields
sqlite3_rtree_dbl *	aCoord
unsigned int *	anQueue
sqlite3_rtree_dbl *	aParam
sqlite3_value **	apSqlParam
int	eParentWithin
int	eWithin
int	iLevel
sqlite3_int64	iRowid
int	mxLevel
int	nCoord
int	nParam
void *	pContext
void *	pUser
sqlite3_rtree_dbl	rParentScore
sqlite3_rtree_dbl	rScore
void()(void )	xDelUser

◆ Fts5PhraseIter

struct Fts5PhraseIter

Data Fields
const unsigned char *	a
const unsigned char *	b

◆ Fts5ExtensionApi

struct Fts5ExtensionApi

Data Fields
int	iVersion
int()(Fts5Context )	xColumnCount
int()(Fts5Context , int iCol, const char *pz, int pn)	xColumnLocale
int()(Fts5Context , int iCol, int *pnToken)	xColumnSize
int()(Fts5Context , int iCol, const char *pz, int pn)	xColumnText
int()(Fts5Context , int iCol, sqlite3_int64 *pnToken)	xColumnTotalSize
void ()(Fts5Context *, int bClear)	xGetAuxdata
int()(Fts5Context , int iIdx, int piPhrase, int piCol, int *piOff)	xInst
int()(Fts5Context , int *pnInst)	xInstCount
int()(Fts5Context , int iIdx, int iToken, const char *, int )	xInstToken
int()(Fts5Context )	xPhraseCount
int()(Fts5Context , int iPhrase, Fts5PhraseIter , int , int *)	xPhraseFirst
int()(Fts5Context , int iPhrase, Fts5PhraseIter , int )	xPhraseFirstColumn
void()(Fts5Context , Fts5PhraseIter , int piCol, int *piOff)	xPhraseNext
void()(Fts5Context , Fts5PhraseIter , int piCol)	xPhraseNextColumn
int()(Fts5Context , int iPhrase)	xPhraseSize
int()(Fts5Context , int iPhrase, void pUserData, int()(const Fts5ExtensionApi , Fts5Context , void *))	xQueryPhrase
int()(Fts5Context , int iPhrase, int iToken, const char *ppToken, int pnToken)	xQueryToken
int()(Fts5Context , sqlite3_int64 *pnRow)	xRowCount
sqlite3_int64()(Fts5Context )	xRowid
int()(Fts5Context , void pAux, void(xDelete)(void *))	xSetAuxdata
int()(Fts5Context , const char pText, int nText, void pCtx, int(xToken)(void , int, const char *, int, int, int))	xTokenize
int()(Fts5Context , const char pText, int nText, const char pLocale, int nLocale, void pCtx, int(xToken)(void , int, const char , int, int, int))	xTokenize_v2
void ()(Fts5Context *)	xUserData

◆ fts5_tokenizer_v2

struct fts5_tokenizer_v2

Data Fields
int	iVersion
int()(void , const char azArg, int nArg, Fts5Tokenizer ppOut)	xCreate
void()(Fts5Tokenizer )	xDelete
int()(Fts5Tokenizer , void pCtx, int flags, const char pText, int nText, const char pLocale, int nLocale, int(xToken)(void pCtx, int tflags, const char pToken, int nToken, int iStart, int iEnd))	xTokenize

◆ fts5_tokenizer

struct fts5_tokenizer

Data Fields
int()(void , const char azArg, int nArg, Fts5Tokenizer ppOut)	xCreate
void()(Fts5Tokenizer )	xDelete
int()(Fts5Tokenizer , void pCtx, int flags, const char pText, int nText, int(xToken)(void pCtx, int tflags, const char *pToken, int nToken, int iStart, int iEnd))	xTokenize

◆ fts5_api

struct fts5_api

Data Fields
int	iVersion
int()(fts5_api pApi, const char zName, void pUserData, fts5_extension_function xFunction, void(xDestroy)(void ))	xCreateFunction
int()(fts5_api pApi, const char zName, void pUserData, fts5_tokenizer pTokenizer, void(xDestroy)(void *))	xCreateTokenizer
int()(fts5_api pApi, const char zName, void pUserData, fts5_tokenizer_v2 pTokenizer, void(xDestroy)(void *))	xCreateTokenizer_v2
int()(fts5_api pApi, const char zName, void ppUserData, fts5_tokenizer pTokenizer)	xFindTokenizer
int()(fts5_api pApi, const char zName, void ppUserData, fts5_tokenizer_v2 *ppTokenizer)	xFindTokenizer_v2

Macro Definition Documentation

◆ _FTS5_H

#define _FTS5_H

◆ _SQLITE3RTREE_H_

#define _SQLITE3RTREE_H_

◆ FTS5_TOKEN_COLOCATED

#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */

◆ FTS5_TOKENIZE_AUX

#define FTS5_TOKENIZE_AUX 0x0008

◆ FTS5_TOKENIZE_DOCUMENT

#define FTS5_TOKENIZE_DOCUMENT 0x0004

◆ FTS5_TOKENIZE_PREFIX

#define FTS5_TOKENIZE_PREFIX 0x0002

◆ FTS5_TOKENIZE_QUERY

#define FTS5_TOKENIZE_QUERY 0x0001

◆ FULLY_WITHIN

#define FULLY_WITHIN 2 /* Object fully contained within query region */

◆ NOT_WITHIN

#define NOT_WITHIN 0 /* Object completely outside of query region */

◆ PARTLY_WITHIN

#define PARTLY_WITHIN 1 /* Object partially overlaps query region */

◆ SQLITE3_TEXT

#define SQLITE3_TEXT 3

◆ SQLITE_ABORT

#define SQLITE_ABORT 4 /* Callback routine requested an abort */

◆ SQLITE_ABORT_ROLLBACK

#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8))

◆ SQLITE_ACCESS_EXISTS

#define SQLITE_ACCESS_EXISTS 0

◆ SQLITE_ACCESS_READ

#define SQLITE_ACCESS_READ 2 /* Unused */

◆ SQLITE_ACCESS_READWRITE

#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */

◆ SQLITE_ALTER_TABLE

#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */

◆ SQLITE_ANALYZE

#define SQLITE_ANALYZE 28 /* Table Name NULL */

◆ SQLITE_ANY

#define SQLITE_ANY 5 /* Deprecated */

◆ SQLITE_API

#define SQLITE_API

◆ SQLITE_APICALL

#define SQLITE_APICALL

◆ SQLITE_ATTACH

#define SQLITE_ATTACH 24 /* Filename NULL */

◆ SQLITE_AUTH

#define SQLITE_AUTH 23 /* Authorization denied */

◆ SQLITE_AUTH_USER

#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8))

◆ SQLITE_BLOB

#define SQLITE_BLOB 4

◆ SQLITE_BUSY

#define SQLITE_BUSY 5 /* The database file is locked */

◆ SQLITE_BUSY_RECOVERY

#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))

◆ SQLITE_BUSY_SNAPSHOT

#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8))

◆ SQLITE_BUSY_TIMEOUT

#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<8))

◆ SQLITE_CALLBACK

#define SQLITE_CALLBACK

◆ SQLITE_CANTOPEN

#define SQLITE_CANTOPEN 14 /* Unable to open the database file */

◆ SQLITE_CANTOPEN_CONVPATH

#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8))

◆ SQLITE_CANTOPEN_DIRTYWAL

#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */

◆ SQLITE_CANTOPEN_FULLPATH

#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8))

◆ SQLITE_CANTOPEN_ISDIR

#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8))

◆ SQLITE_CANTOPEN_NOTEMPDIR

#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))

◆ SQLITE_CANTOPEN_SYMLINK

#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8))

◆ SQLITE_CDECL

#define SQLITE_CDECL

◆ SQLITE_CHECKPOINT_FULL

#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */

◆ SQLITE_CHECKPOINT_PASSIVE

#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */

◆ SQLITE_CHECKPOINT_RESTART

#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for readers */

◆ SQLITE_CHECKPOINT_TRUNCATE

#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */

◆ SQLITE_CONFIG_COVERING_INDEX_SCAN

#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

◆ SQLITE_CONFIG_GETMALLOC

#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

◆ SQLITE_CONFIG_GETMUTEX

#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

◆ SQLITE_CONFIG_GETPCACHE

#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */

◆ SQLITE_CONFIG_GETPCACHE2

#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

◆ SQLITE_CONFIG_HEAP

#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */

◆ SQLITE_CONFIG_LOG

#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */

◆ SQLITE_CONFIG_LOOKASIDE

#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */

◆ SQLITE_CONFIG_MALLOC

#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

◆ SQLITE_CONFIG_MEMDB_MAXSIZE

#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */

◆ SQLITE_CONFIG_MEMSTATUS

#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

◆ SQLITE_CONFIG_MMAP_SIZE

#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

◆ SQLITE_CONFIG_MULTITHREAD

#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */

◆ SQLITE_CONFIG_MUTEX

#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

◆ SQLITE_CONFIG_PAGECACHE

#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */

◆ SQLITE_CONFIG_PCACHE

#define SQLITE_CONFIG_PCACHE 14 /* no-op */

◆ SQLITE_CONFIG_PCACHE2

#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

◆ SQLITE_CONFIG_PCACHE_HDRSZ

#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */

◆ SQLITE_CONFIG_PMASZ

#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

◆ SQLITE_CONFIG_ROWID_IN_VIEW

#define SQLITE_CONFIG_ROWID_IN_VIEW 30 /* int* */

◆ SQLITE_CONFIG_SCRATCH

#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */

◆ SQLITE_CONFIG_SERIALIZED

#define SQLITE_CONFIG_SERIALIZED 3 /* nil */

◆ SQLITE_CONFIG_SINGLETHREAD

#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

◆ SQLITE_CONFIG_SMALL_MALLOC

#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */

◆ SQLITE_CONFIG_SORTERREF_SIZE

#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */

◆ SQLITE_CONFIG_SQLLOG

#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */

◆ SQLITE_CONFIG_STMTJRNL_SPILL

#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */

◆ SQLITE_CONFIG_URI

#define SQLITE_CONFIG_URI 17 /* int */

◆ SQLITE_CONFIG_WIN32_HEAPSIZE

#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

◆ SQLITE_CONSTRAINT

#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */

◆ SQLITE_CONSTRAINT_CHECK

#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8))

◆ SQLITE_CONSTRAINT_COMMITHOOK

#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8))

◆ SQLITE_CONSTRAINT_DATATYPE

#define SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT |(12<<8))

◆ SQLITE_CONSTRAINT_FOREIGNKEY

#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8))

◆ SQLITE_CONSTRAINT_FUNCTION

#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8))

◆ SQLITE_CONSTRAINT_NOTNULL

#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8))

◆ SQLITE_CONSTRAINT_PINNED

#define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8))

◆ SQLITE_CONSTRAINT_PRIMARYKEY

#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8))

◆ SQLITE_CONSTRAINT_ROWID

#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8))

◆ SQLITE_CONSTRAINT_TRIGGER

#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8))

◆ SQLITE_CONSTRAINT_UNIQUE

#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8))

◆ SQLITE_CONSTRAINT_VTAB

#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8))

◆ SQLITE_COPY

#define SQLITE_COPY 0 /* No longer used */

◆ SQLITE_CORRUPT

#define SQLITE_CORRUPT 11 /* The database disk image is malformed */

◆ SQLITE_CORRUPT_INDEX

#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8))

◆ SQLITE_CORRUPT_SEQUENCE

#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8))

◆ SQLITE_CORRUPT_VTAB

#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))

◆ SQLITE_CREATE_INDEX

#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */

◆ SQLITE_CREATE_TABLE

#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */

◆ SQLITE_CREATE_TEMP_INDEX

#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */

◆ SQLITE_CREATE_TEMP_TABLE

#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

◆ SQLITE_CREATE_TEMP_TRIGGER

#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */

◆ SQLITE_CREATE_TEMP_VIEW

#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

◆ SQLITE_CREATE_TRIGGER

#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */

◆ SQLITE_CREATE_VIEW

#define SQLITE_CREATE_VIEW 8 /* View Name NULL */

◆ SQLITE_CREATE_VTABLE

#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */

◆ SQLITE_DBCONFIG_DEFENSIVE

#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */

◆ SQLITE_DBCONFIG_DQS_DDL

#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */

◆ SQLITE_DBCONFIG_DQS_DML

#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE

#define SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE 1020 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE

#define SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE 1021 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_COMMENTS

#define SQLITE_DBCONFIG_ENABLE_COMMENTS 1022 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_FKEY

#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER

#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION

#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_QPSG

#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_TRIGGER

#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

◆ SQLITE_DBCONFIG_ENABLE_VIEW

#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */

◆ SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */

◆ SQLITE_DBCONFIG_LEGACY_FILE_FORMAT

#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */

◆ SQLITE_DBCONFIG_LOOKASIDE

#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */

◆ SQLITE_DBCONFIG_MAINDBNAME

#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */

◆ SQLITE_DBCONFIG_MAX

#define SQLITE_DBCONFIG_MAX 1022 /* Largest DBCONFIG */

◆ SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE

#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */

◆ SQLITE_DBCONFIG_RESET_DATABASE

#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */

◆ SQLITE_DBCONFIG_REVERSE_SCANORDER

#define SQLITE_DBCONFIG_REVERSE_SCANORDER 1019 /* int int* */

◆ SQLITE_DBCONFIG_STMT_SCANSTATUS

#define SQLITE_DBCONFIG_STMT_SCANSTATUS 1018 /* int int* */

◆ SQLITE_DBCONFIG_TRIGGER_EQP

#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */

◆ SQLITE_DBCONFIG_TRUSTED_SCHEMA

#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */

◆ SQLITE_DBCONFIG_WRITABLE_SCHEMA

#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */

◆ SQLITE_DBSTATUS_CACHE_HIT

#define SQLITE_DBSTATUS_CACHE_HIT 7

◆ SQLITE_DBSTATUS_CACHE_MISS

#define SQLITE_DBSTATUS_CACHE_MISS 8

◆ SQLITE_DBSTATUS_CACHE_SPILL

#define SQLITE_DBSTATUS_CACHE_SPILL 12

◆ SQLITE_DBSTATUS_CACHE_USED

#define SQLITE_DBSTATUS_CACHE_USED 1

◆ SQLITE_DBSTATUS_CACHE_USED_SHARED

#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11

◆ SQLITE_DBSTATUS_CACHE_WRITE

#define SQLITE_DBSTATUS_CACHE_WRITE 9

◆ SQLITE_DBSTATUS_DEFERRED_FKS

#define SQLITE_DBSTATUS_DEFERRED_FKS 10

◆ SQLITE_DBSTATUS_LOOKASIDE_HIT

#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

◆ SQLITE_DBSTATUS_LOOKASIDE_USED

#define SQLITE_DBSTATUS_LOOKASIDE_USED 0

◆ SQLITE_DBSTATUS_MAX

#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */

◆ SQLITE_DBSTATUS_SCHEMA_USED

#define SQLITE_DBSTATUS_SCHEMA_USED 2

◆ SQLITE_DBSTATUS_STMT_USED

#define SQLITE_DBSTATUS_STMT_USED 3

◆ SQLITE_DELETE

#define SQLITE_DELETE 9 /* Table Name NULL */

◆ SQLITE_DENY

#define SQLITE_DENY 1 /* Abort the SQL statement with an error */

◆ SQLITE_DEPRECATED

#define SQLITE_DEPRECATED

◆ SQLITE_DESERIALIZE_FREEONCLOSE

#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */

◆ SQLITE_DESERIALIZE_READONLY

#define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */

◆ SQLITE_DESERIALIZE_RESIZEABLE

#define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */

◆ SQLITE_DETACH

#define SQLITE_DETACH 25 /* Database Name NULL */

◆ SQLITE_DETERMINISTIC

#define SQLITE_DETERMINISTIC 0x000000800

◆ SQLITE_DIRECTONLY

#define SQLITE_DIRECTONLY 0x000080000

◆ SQLITE_DONE

#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */

◆ SQLITE_DROP_INDEX

#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */

◆ SQLITE_DROP_TABLE

#define SQLITE_DROP_TABLE 11 /* Table Name NULL */

◆ SQLITE_DROP_TEMP_INDEX

#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */

◆ SQLITE_DROP_TEMP_TABLE

#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

◆ SQLITE_DROP_TEMP_TRIGGER

#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */

◆ SQLITE_DROP_TEMP_VIEW

#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

◆ SQLITE_DROP_TRIGGER

#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */

◆ SQLITE_DROP_VIEW

#define SQLITE_DROP_VIEW 17 /* View Name NULL */

◆ SQLITE_DROP_VTABLE

#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */

◆ SQLITE_EMPTY

#define SQLITE_EMPTY 16 /* Internal use only */

◆ SQLITE_ERROR

#define SQLITE_ERROR 1 /* Generic error */

◆ SQLITE_ERROR_MISSING_COLLSEQ

#define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8))

◆ SQLITE_ERROR_RETRY

#define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8))

◆ SQLITE_ERROR_SNAPSHOT

#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8))

◆ SQLITE_EXPERIMENTAL

#define SQLITE_EXPERIMENTAL

◆ SQLITE_EXTERN

#define SQLITE_EXTERN extern

◆ SQLITE_FAIL

#define SQLITE_FAIL 3

◆ SQLITE_FCNTL_BEGIN_ATOMIC_WRITE

#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31

◆ SQLITE_FCNTL_BLOCK_ON_CONNECT

#define SQLITE_FCNTL_BLOCK_ON_CONNECT 44

◆ SQLITE_FCNTL_BUSYHANDLER

#define SQLITE_FCNTL_BUSYHANDLER 15

◆ SQLITE_FCNTL_CHUNK_SIZE

#define SQLITE_FCNTL_CHUNK_SIZE 6

◆ SQLITE_FCNTL_CKPT_DONE

#define SQLITE_FCNTL_CKPT_DONE 37

◆ SQLITE_FCNTL_CKPT_START

#define SQLITE_FCNTL_CKPT_START 39

◆ SQLITE_FCNTL_CKSM_FILE

#define SQLITE_FCNTL_CKSM_FILE 41

◆ SQLITE_FCNTL_COMMIT_ATOMIC_WRITE

#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32

◆ SQLITE_FCNTL_COMMIT_PHASETWO

#define SQLITE_FCNTL_COMMIT_PHASETWO 22

◆ SQLITE_FCNTL_DATA_VERSION

#define SQLITE_FCNTL_DATA_VERSION 35

◆ SQLITE_FCNTL_EXTERNAL_READER

#define SQLITE_FCNTL_EXTERNAL_READER 40

◆ SQLITE_FCNTL_FILE_POINTER

#define SQLITE_FCNTL_FILE_POINTER 7

◆ SQLITE_FCNTL_GET_LOCKPROXYFILE

#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2

◆ SQLITE_FCNTL_HAS_MOVED

#define SQLITE_FCNTL_HAS_MOVED 20

◆ SQLITE_FCNTL_JOURNAL_POINTER

#define SQLITE_FCNTL_JOURNAL_POINTER 28

◆ SQLITE_FCNTL_LAST_ERRNO

#define SQLITE_FCNTL_LAST_ERRNO 4

◆ SQLITE_FCNTL_LOCK_TIMEOUT

#define SQLITE_FCNTL_LOCK_TIMEOUT 34

◆ SQLITE_FCNTL_LOCKSTATE

#define SQLITE_FCNTL_LOCKSTATE 1

◆ SQLITE_FCNTL_MMAP_SIZE

#define SQLITE_FCNTL_MMAP_SIZE 18

◆ SQLITE_FCNTL_NULL_IO

#define SQLITE_FCNTL_NULL_IO 43

◆ SQLITE_FCNTL_OVERWRITE

#define SQLITE_FCNTL_OVERWRITE 11

◆ SQLITE_FCNTL_PDB

#define SQLITE_FCNTL_PDB 30

◆ SQLITE_FCNTL_PERSIST_WAL

#define SQLITE_FCNTL_PERSIST_WAL 10

◆ SQLITE_FCNTL_POWERSAFE_OVERWRITE

#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

◆ SQLITE_FCNTL_PRAGMA

#define SQLITE_FCNTL_PRAGMA 14

◆ SQLITE_FCNTL_RBU

#define SQLITE_FCNTL_RBU 26

◆ SQLITE_FCNTL_RESERVE_BYTES

#define SQLITE_FCNTL_RESERVE_BYTES 38

◆ SQLITE_FCNTL_RESET_CACHE

#define SQLITE_FCNTL_RESET_CACHE 42

◆ SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE

#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33

◆ SQLITE_FCNTL_SET_LOCKPROXYFILE

#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3

◆ SQLITE_FCNTL_SIZE_HINT

#define SQLITE_FCNTL_SIZE_HINT 5

◆ SQLITE_FCNTL_SIZE_LIMIT

#define SQLITE_FCNTL_SIZE_LIMIT 36

◆ SQLITE_FCNTL_SYNC

#define SQLITE_FCNTL_SYNC 21

◆ SQLITE_FCNTL_SYNC_OMITTED

#define SQLITE_FCNTL_SYNC_OMITTED 8

◆ SQLITE_FCNTL_TEMPFILENAME

#define SQLITE_FCNTL_TEMPFILENAME 16

◆ SQLITE_FCNTL_TRACE

#define SQLITE_FCNTL_TRACE 19

◆ SQLITE_FCNTL_VFS_POINTER

#define SQLITE_FCNTL_VFS_POINTER 27

◆ SQLITE_FCNTL_VFSNAME

#define SQLITE_FCNTL_VFSNAME 12

◆ SQLITE_FCNTL_WAL_BLOCK

#define SQLITE_FCNTL_WAL_BLOCK 24

◆ SQLITE_FCNTL_WIN32_AV_RETRY

#define SQLITE_FCNTL_WIN32_AV_RETRY 9

◆ SQLITE_FCNTL_WIN32_GET_HANDLE

#define SQLITE_FCNTL_WIN32_GET_HANDLE 29

◆ SQLITE_FCNTL_WIN32_SET_HANDLE

#define SQLITE_FCNTL_WIN32_SET_HANDLE 23

◆ SQLITE_FCNTL_ZIPVFS

#define SQLITE_FCNTL_ZIPVFS 25

◆ SQLITE_FLOAT

#define SQLITE_FLOAT 2

◆ SQLITE_FORMAT

#define SQLITE_FORMAT 24 /* Not used */

◆ SQLITE_FULL

#define SQLITE_FULL 13 /* Insertion failed because database is full */

◆ SQLITE_FUNCTION

#define SQLITE_FUNCTION 31 /* NULL Function Name */

◆ SQLITE_GET_LOCKPROXYFILE

#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

◆ SQLITE_IGNORE

#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */

◆ SQLITE_INDEX_CONSTRAINT_EQ

#define SQLITE_INDEX_CONSTRAINT_EQ 2

◆ SQLITE_INDEX_CONSTRAINT_FUNCTION

#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150

◆ SQLITE_INDEX_CONSTRAINT_GE

#define SQLITE_INDEX_CONSTRAINT_GE 32

◆ SQLITE_INDEX_CONSTRAINT_GLOB

#define SQLITE_INDEX_CONSTRAINT_GLOB 66

◆ SQLITE_INDEX_CONSTRAINT_GT

#define SQLITE_INDEX_CONSTRAINT_GT 4

◆ SQLITE_INDEX_CONSTRAINT_IS

#define SQLITE_INDEX_CONSTRAINT_IS 72

◆ SQLITE_INDEX_CONSTRAINT_ISNOT

#define SQLITE_INDEX_CONSTRAINT_ISNOT 69

◆ SQLITE_INDEX_CONSTRAINT_ISNOTNULL

#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70

◆ SQLITE_INDEX_CONSTRAINT_ISNULL

#define SQLITE_INDEX_CONSTRAINT_ISNULL 71

◆ SQLITE_INDEX_CONSTRAINT_LE

#define SQLITE_INDEX_CONSTRAINT_LE 8

◆ SQLITE_INDEX_CONSTRAINT_LIKE

#define SQLITE_INDEX_CONSTRAINT_LIKE 65

◆ SQLITE_INDEX_CONSTRAINT_LIMIT

#define SQLITE_INDEX_CONSTRAINT_LIMIT 73

◆ SQLITE_INDEX_CONSTRAINT_LT

#define SQLITE_INDEX_CONSTRAINT_LT 16

◆ SQLITE_INDEX_CONSTRAINT_MATCH

#define SQLITE_INDEX_CONSTRAINT_MATCH 64

◆ SQLITE_INDEX_CONSTRAINT_NE

#define SQLITE_INDEX_CONSTRAINT_NE 68

◆ SQLITE_INDEX_CONSTRAINT_OFFSET

#define SQLITE_INDEX_CONSTRAINT_OFFSET 74

◆ SQLITE_INDEX_CONSTRAINT_REGEXP

#define SQLITE_INDEX_CONSTRAINT_REGEXP 67

◆ SQLITE_INDEX_SCAN_HEX

#define SQLITE_INDEX_SCAN_HEX 0x00000002 /* Display idxNum as hex */

◆ SQLITE_INDEX_SCAN_UNIQUE

#define SQLITE_INDEX_SCAN_UNIQUE 0x00000001 /* Scan visits at most 1 row */

◆ SQLITE_INNOCUOUS

#define SQLITE_INNOCUOUS 0x000200000

◆ SQLITE_INSERT

#define SQLITE_INSERT 18 /* Table Name NULL */

◆ SQLITE_INTEGER

#define SQLITE_INTEGER 1

◆ SQLITE_INTERNAL

#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */

◆ SQLITE_INTERRUPT

#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/

◆ SQLITE_IOCAP_ATOMIC

#define SQLITE_IOCAP_ATOMIC 0x00000001

◆ SQLITE_IOCAP_ATOMIC16K

#define SQLITE_IOCAP_ATOMIC16K 0x00000040

◆ SQLITE_IOCAP_ATOMIC1K

#define SQLITE_IOCAP_ATOMIC1K 0x00000004

◆ SQLITE_IOCAP_ATOMIC2K

#define SQLITE_IOCAP_ATOMIC2K 0x00000008

◆ SQLITE_IOCAP_ATOMIC32K

#define SQLITE_IOCAP_ATOMIC32K 0x00000080

◆ SQLITE_IOCAP_ATOMIC4K

#define SQLITE_IOCAP_ATOMIC4K 0x00000010

◆ SQLITE_IOCAP_ATOMIC512

#define SQLITE_IOCAP_ATOMIC512 0x00000002

◆ SQLITE_IOCAP_ATOMIC64K

#define SQLITE_IOCAP_ATOMIC64K 0x00000100

◆ SQLITE_IOCAP_ATOMIC8K

#define SQLITE_IOCAP_ATOMIC8K 0x00000020

◆ SQLITE_IOCAP_BATCH_ATOMIC

#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000

◆ SQLITE_IOCAP_IMMUTABLE

#define SQLITE_IOCAP_IMMUTABLE 0x00002000

◆ SQLITE_IOCAP_POWERSAFE_OVERWRITE

#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

◆ SQLITE_IOCAP_SAFE_APPEND

#define SQLITE_IOCAP_SAFE_APPEND 0x00000200

◆ SQLITE_IOCAP_SEQUENTIAL

#define SQLITE_IOCAP_SEQUENTIAL 0x00000400

◆ SQLITE_IOCAP_SUBPAGE_READ

#define SQLITE_IOCAP_SUBPAGE_READ 0x00008000

◆ SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN

#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

◆ SQLITE_IOERR

#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */

◆ SQLITE_IOERR_ACCESS

#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))

◆ SQLITE_IOERR_AUTH

#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8))

◆ SQLITE_IOERR_BEGIN_ATOMIC

#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8))

◆ SQLITE_IOERR_BLOCKED

#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))

◆ SQLITE_IOERR_CHECKRESERVEDLOCK

#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

◆ SQLITE_IOERR_CLOSE

#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))

◆ SQLITE_IOERR_COMMIT_ATOMIC

#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8))

◆ SQLITE_IOERR_CONVPATH

#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8))

◆ SQLITE_IOERR_CORRUPTFS

#define SQLITE_IOERR_CORRUPTFS (SQLITE_IOERR | (33<<8))

◆ SQLITE_IOERR_DATA

#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8))

◆ SQLITE_IOERR_DELETE

#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))

◆ SQLITE_IOERR_DELETE_NOENT

#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8))

◆ SQLITE_IOERR_DIR_CLOSE

#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))

◆ SQLITE_IOERR_DIR_FSYNC

#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))

◆ SQLITE_IOERR_FSTAT

#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))

◆ SQLITE_IOERR_FSYNC

#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))

◆ SQLITE_IOERR_GETTEMPPATH

#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8))

◆ SQLITE_IOERR_IN_PAGE

#define SQLITE_IOERR_IN_PAGE (SQLITE_IOERR | (34<<8))

◆ SQLITE_IOERR_LOCK

#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))

◆ SQLITE_IOERR_MMAP

#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8))

◆ SQLITE_IOERR_NOMEM

#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))

◆ SQLITE_IOERR_RDLOCK

#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))

◆ SQLITE_IOERR_READ

#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))

◆ SQLITE_IOERR_ROLLBACK_ATOMIC

#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8))

◆ SQLITE_IOERR_SEEK

#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))

◆ SQLITE_IOERR_SHMLOCK

#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))

◆ SQLITE_IOERR_SHMMAP

#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))

◆ SQLITE_IOERR_SHMOPEN

#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))

◆ SQLITE_IOERR_SHMSIZE

#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))

◆ SQLITE_IOERR_SHORT_READ

#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))

◆ SQLITE_IOERR_TRUNCATE

#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))

◆ SQLITE_IOERR_UNLOCK

#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))

◆ SQLITE_IOERR_VNODE

#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8))

◆ SQLITE_IOERR_WRITE

#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))

◆ SQLITE_LAST_ERRNO

#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

◆ SQLITE_LIMIT_ATTACHED

#define SQLITE_LIMIT_ATTACHED 7

◆ SQLITE_LIMIT_COLUMN

#define SQLITE_LIMIT_COLUMN 2

◆ SQLITE_LIMIT_COMPOUND_SELECT

#define SQLITE_LIMIT_COMPOUND_SELECT 4

◆ SQLITE_LIMIT_EXPR_DEPTH

#define SQLITE_LIMIT_EXPR_DEPTH 3

◆ SQLITE_LIMIT_FUNCTION_ARG

#define SQLITE_LIMIT_FUNCTION_ARG 6

◆ SQLITE_LIMIT_LENGTH

#define SQLITE_LIMIT_LENGTH 0

◆ SQLITE_LIMIT_LIKE_PATTERN_LENGTH

#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

◆ SQLITE_LIMIT_SQL_LENGTH

#define SQLITE_LIMIT_SQL_LENGTH 1

◆ SQLITE_LIMIT_TRIGGER_DEPTH

#define SQLITE_LIMIT_TRIGGER_DEPTH 10

◆ SQLITE_LIMIT_VARIABLE_NUMBER

#define SQLITE_LIMIT_VARIABLE_NUMBER 9

◆ SQLITE_LIMIT_VDBE_OP

#define SQLITE_LIMIT_VDBE_OP 5

◆ SQLITE_LIMIT_WORKER_THREADS

#define SQLITE_LIMIT_WORKER_THREADS 11

◆ SQLITE_LOCK_EXCLUSIVE

#define SQLITE_LOCK_EXCLUSIVE 4 /* xLock() only */

◆ SQLITE_LOCK_NONE

#define SQLITE_LOCK_NONE 0 /* xUnlock() only */

◆ SQLITE_LOCK_PENDING

#define SQLITE_LOCK_PENDING 3 /* xLock() only */

◆ SQLITE_LOCK_RESERVED

#define SQLITE_LOCK_RESERVED 2 /* xLock() only */

◆ SQLITE_LOCK_SHARED

#define SQLITE_LOCK_SHARED 1 /* xLock() or xUnlock() */

◆ SQLITE_LOCKED

#define SQLITE_LOCKED 6 /* A table in the database is locked */

◆ SQLITE_LOCKED_SHAREDCACHE

#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))

◆ SQLITE_LOCKED_VTAB

#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8))

◆ SQLITE_MISMATCH

#define SQLITE_MISMATCH 20 /* Data type mismatch */

◆ SQLITE_MISUSE

#define SQLITE_MISUSE 21 /* Library used incorrectly */

◆ SQLITE_MUTEX_FAST

#define SQLITE_MUTEX_FAST 0

◆ SQLITE_MUTEX_RECURSIVE

#define SQLITE_MUTEX_RECURSIVE 1

◆ SQLITE_MUTEX_STATIC_APP1

#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */

◆ SQLITE_MUTEX_STATIC_APP2

#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */

◆ SQLITE_MUTEX_STATIC_APP3

#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */

◆ SQLITE_MUTEX_STATIC_LRU

#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

◆ SQLITE_MUTEX_STATIC_LRU2

#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

◆ SQLITE_MUTEX_STATIC_MAIN

#define SQLITE_MUTEX_STATIC_MAIN 2

◆ SQLITE_MUTEX_STATIC_MASTER

#define SQLITE_MUTEX_STATIC_MASTER 2

◆ SQLITE_MUTEX_STATIC_MEM

#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

◆ SQLITE_MUTEX_STATIC_MEM2

#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

◆ SQLITE_MUTEX_STATIC_OPEN

#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

◆ SQLITE_MUTEX_STATIC_PMEM

#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

◆ SQLITE_MUTEX_STATIC_PRNG

#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */

◆ SQLITE_MUTEX_STATIC_VFS1

#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */

◆ SQLITE_MUTEX_STATIC_VFS2

#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */

◆ SQLITE_MUTEX_STATIC_VFS3

#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */

◆ SQLITE_NOLFS

#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */

◆ SQLITE_NOMEM

#define SQLITE_NOMEM 7 /* A malloc() failed */

◆ SQLITE_NOTADB

#define SQLITE_NOTADB 26 /* File opened that is not a database file */

◆ SQLITE_NOTFOUND

#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */

◆ SQLITE_NOTICE

#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */

◆ SQLITE_NOTICE_RBU

#define SQLITE_NOTICE_RBU (SQLITE_NOTICE | (3<<8))

◆ SQLITE_NOTICE_RECOVER_ROLLBACK

#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

◆ SQLITE_NOTICE_RECOVER_WAL

#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8))

◆ SQLITE_NULL

#define SQLITE_NULL 5

◆ SQLITE_OK

#define SQLITE_OK 0 /* Successful result */

◆ SQLITE_OK_LOAD_PERMANENTLY

#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8))

◆ SQLITE_OK_SYMLINK

#define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8)) /* internal use only */

◆ SQLITE_OPEN_AUTOPROXY

#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

◆ SQLITE_OPEN_CREATE

#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_DELETEONCLOSE

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

◆ SQLITE_OPEN_EXCLUSIVE

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

◆ SQLITE_OPEN_EXRESCODE

#define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */

◆ SQLITE_OPEN_FULLMUTEX

#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_MAIN_DB

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

◆ SQLITE_OPEN_MAIN_JOURNAL

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

◆ SQLITE_OPEN_MASTER_JOURNAL

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

◆ SQLITE_OPEN_MEMORY

#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_NOFOLLOW

#define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_NOMUTEX

#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_PRIVATECACHE

#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_READONLY

#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_READWRITE

#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_SHAREDCACHE

#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_SUBJOURNAL

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

◆ SQLITE_OPEN_SUPER_JOURNAL

#define SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */

◆ SQLITE_OPEN_TEMP_DB

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

◆ SQLITE_OPEN_TEMP_JOURNAL

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

◆ SQLITE_OPEN_TRANSIENT_DB

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

◆ SQLITE_OPEN_URI

#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */

◆ SQLITE_OPEN_WAL

#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */

◆ SQLITE_PERM

#define SQLITE_PERM 3 /* Access permission denied */

◆ SQLITE_PRAGMA

#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */

◆ SQLITE_PREPARE_DONT_LOG

#define SQLITE_PREPARE_DONT_LOG 0x10

◆ SQLITE_PREPARE_NO_VTAB

#define SQLITE_PREPARE_NO_VTAB 0x04

◆ SQLITE_PREPARE_NORMALIZE

#define SQLITE_PREPARE_NORMALIZE 0x02

◆ SQLITE_PREPARE_PERSISTENT

#define SQLITE_PREPARE_PERSISTENT 0x01

◆ SQLITE_PROTOCOL

#define SQLITE_PROTOCOL 15 /* Database lock protocol error */

◆ SQLITE_RANGE

#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */

◆ SQLITE_READ

#define SQLITE_READ 20 /* Table Name Column Name */

◆ SQLITE_READONLY

#define SQLITE_READONLY 8 /* Attempt to write a readonly database */

◆ SQLITE_READONLY_CANTINIT

#define SQLITE_READONLY_CANTINIT (SQLITE_READONLY | (5<<8))

◆ SQLITE_READONLY_CANTLOCK

#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))

◆ SQLITE_READONLY_DBMOVED

#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8))

◆ SQLITE_READONLY_DIRECTORY

#define SQLITE_READONLY_DIRECTORY (SQLITE_READONLY | (6<<8))

◆ SQLITE_READONLY_RECOVERY

#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))

◆ SQLITE_READONLY_ROLLBACK

#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8))

◆ SQLITE_RECURSIVE

#define SQLITE_RECURSIVE 33 /* NULL NULL */

◆ SQLITE_REINDEX

#define SQLITE_REINDEX 27 /* Index Name NULL */

◆ SQLITE_REPLACE

#define SQLITE_REPLACE 5

◆ SQLITE_RESULT_SUBTYPE

#define SQLITE_RESULT_SUBTYPE 0x001000000

◆ SQLITE_ROLLBACK

#define SQLITE_ROLLBACK 1

◆ SQLITE_ROW

#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */

◆ SQLITE_SAVEPOINT

#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

◆ SQLITE_SCANSTAT_COMPLEX

#define SQLITE_SCANSTAT_COMPLEX 0x0001

◆ SQLITE_SCANSTAT_EST

#define SQLITE_SCANSTAT_EST 2

◆ SQLITE_SCANSTAT_EXPLAIN

#define SQLITE_SCANSTAT_EXPLAIN 4

◆ SQLITE_SCANSTAT_NAME

#define SQLITE_SCANSTAT_NAME 3

◆ SQLITE_SCANSTAT_NCYCLE

#define SQLITE_SCANSTAT_NCYCLE 7

◆ SQLITE_SCANSTAT_NLOOP

#define SQLITE_SCANSTAT_NLOOP 0

◆ SQLITE_SCANSTAT_NVISIT

#define SQLITE_SCANSTAT_NVISIT 1

◆ SQLITE_SCANSTAT_PARENTID

#define SQLITE_SCANSTAT_PARENTID 6

◆ SQLITE_SCANSTAT_SELECTID

#define SQLITE_SCANSTAT_SELECTID 5

◆ SQLITE_SCHEMA

#define SQLITE_SCHEMA 17 /* The database schema changed */

◆ SQLITE_SELECT

#define SQLITE_SELECT 21 /* NULL NULL */

◆ SQLITE_SELFORDER1

#define SQLITE_SELFORDER1 0x002000000

◆ SQLITE_SERIALIZE_NOCOPY

#define SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */

◆ SQLITE_SET_LOCKPROXYFILE

#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

◆ SQLITE_SETLK_BLOCK_ON_CONNECT

#define SQLITE_SETLK_BLOCK_ON_CONNECT 0x01

◆ SQLITE_SHM_EXCLUSIVE

#define SQLITE_SHM_EXCLUSIVE 8

◆ SQLITE_SHM_LOCK

#define SQLITE_SHM_LOCK 2

◆ SQLITE_SHM_NLOCK

#define SQLITE_SHM_NLOCK 8

◆ SQLITE_SHM_SHARED

#define SQLITE_SHM_SHARED 4

◆ SQLITE_SHM_UNLOCK

#define SQLITE_SHM_UNLOCK 1

◆ SQLITE_SOURCE_ID

#define SQLITE_SOURCE_ID "2025-06-28 14:00:48 2af157d77fb1304a74176eaee7fbc7c7e932d946bf25325e9c26c91db19e3079"

◆ SQLITE_STATIC

#define SQLITE_STATIC ((sqlite3_destructor_type)0)

◆ SQLITE_STATUS_MALLOC_COUNT

#define SQLITE_STATUS_MALLOC_COUNT 9

◆ SQLITE_STATUS_MALLOC_SIZE

#define SQLITE_STATUS_MALLOC_SIZE 5

◆ SQLITE_STATUS_MEMORY_USED

#define SQLITE_STATUS_MEMORY_USED 0

◆ SQLITE_STATUS_PAGECACHE_OVERFLOW

#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2

◆ SQLITE_STATUS_PAGECACHE_SIZE

#define SQLITE_STATUS_PAGECACHE_SIZE 7

◆ SQLITE_STATUS_PAGECACHE_USED

#define SQLITE_STATUS_PAGECACHE_USED 1

◆ SQLITE_STATUS_PARSER_STACK

#define SQLITE_STATUS_PARSER_STACK 6

◆ SQLITE_STATUS_SCRATCH_OVERFLOW

#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */

◆ SQLITE_STATUS_SCRATCH_SIZE

#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */

◆ SQLITE_STATUS_SCRATCH_USED

#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */

◆ SQLITE_STDCALL

#define SQLITE_STDCALL SQLITE_APICALL

◆ SQLITE_STMTSTATUS_AUTOINDEX

#define SQLITE_STMTSTATUS_AUTOINDEX 3

◆ SQLITE_STMTSTATUS_FILTER_HIT

#define SQLITE_STMTSTATUS_FILTER_HIT 8

◆ SQLITE_STMTSTATUS_FILTER_MISS

#define SQLITE_STMTSTATUS_FILTER_MISS 7

◆ SQLITE_STMTSTATUS_FULLSCAN_STEP

#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1

◆ SQLITE_STMTSTATUS_MEMUSED

#define SQLITE_STMTSTATUS_MEMUSED 99

◆ SQLITE_STMTSTATUS_REPREPARE

#define SQLITE_STMTSTATUS_REPREPARE 5

◆ SQLITE_STMTSTATUS_RUN

#define SQLITE_STMTSTATUS_RUN 6

◆ SQLITE_STMTSTATUS_SORT

#define SQLITE_STMTSTATUS_SORT 2

◆ SQLITE_STMTSTATUS_VM_STEP

#define SQLITE_STMTSTATUS_VM_STEP 4

◆ SQLITE_SUBTYPE

#define SQLITE_SUBTYPE 0x000100000

◆ SQLITE_SYNC_DATAONLY

#define SQLITE_SYNC_DATAONLY 0x00010

◆ SQLITE_SYNC_FULL

#define SQLITE_SYNC_FULL 0x00003

◆ SQLITE_SYNC_NORMAL

#define SQLITE_SYNC_NORMAL 0x00002

◆ SQLITE_SYSAPI

#define SQLITE_SYSAPI

◆ SQLITE_TESTCTRL_ALWAYS

#define SQLITE_TESTCTRL_ALWAYS 13

◆ SQLITE_TESTCTRL_ASSERT

#define SQLITE_TESTCTRL_ASSERT 12

◆ SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS

#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

◆ SQLITE_TESTCTRL_BITVEC_TEST

#define SQLITE_TESTCTRL_BITVEC_TEST 8

◆ SQLITE_TESTCTRL_BYTEORDER

#define SQLITE_TESTCTRL_BYTEORDER 22

◆ SQLITE_TESTCTRL_EXPLAIN_STMT

#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

◆ SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS

#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29

◆ SQLITE_TESTCTRL_FAULT_INSTALL

#define SQLITE_TESTCTRL_FAULT_INSTALL 9

◆ SQLITE_TESTCTRL_FIRST

#define SQLITE_TESTCTRL_FIRST 5

◆ SQLITE_TESTCTRL_FK_NO_ACTION

#define SQLITE_TESTCTRL_FK_NO_ACTION 7

◆ SQLITE_TESTCTRL_GETOPT

#define SQLITE_TESTCTRL_GETOPT 16

◆ SQLITE_TESTCTRL_IMPOSTER

#define SQLITE_TESTCTRL_IMPOSTER 25

◆ SQLITE_TESTCTRL_INTERNAL_FUNCTIONS

#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17

◆ SQLITE_TESTCTRL_ISINIT

#define SQLITE_TESTCTRL_ISINIT 23

◆ SQLITE_TESTCTRL_ISKEYWORD

#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */

◆ SQLITE_TESTCTRL_JSON_SELFCHECK

#define SQLITE_TESTCTRL_JSON_SELFCHECK 14

◆ SQLITE_TESTCTRL_LAST

#define SQLITE_TESTCTRL_LAST 34 /* Largest TESTCTRL */

◆ SQLITE_TESTCTRL_LOCALTIME_FAULT

#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18

◆ SQLITE_TESTCTRL_LOGEST

#define SQLITE_TESTCTRL_LOGEST 33

◆ SQLITE_TESTCTRL_NEVER_CORRUPT

#define SQLITE_TESTCTRL_NEVER_CORRUPT 20

◆ SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD

#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19

◆ SQLITE_TESTCTRL_OPTIMIZATIONS

#define SQLITE_TESTCTRL_OPTIMIZATIONS 15

◆ SQLITE_TESTCTRL_PARSER_COVERAGE

#define SQLITE_TESTCTRL_PARSER_COVERAGE 26

◆ SQLITE_TESTCTRL_PENDING_BYTE

#define SQLITE_TESTCTRL_PENDING_BYTE 11

◆ SQLITE_TESTCTRL_PRNG_RESET

#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */

◆ SQLITE_TESTCTRL_PRNG_RESTORE

#define SQLITE_TESTCTRL_PRNG_RESTORE 6

◆ SQLITE_TESTCTRL_PRNG_SAVE

#define SQLITE_TESTCTRL_PRNG_SAVE 5

◆ SQLITE_TESTCTRL_PRNG_SEED

#define SQLITE_TESTCTRL_PRNG_SEED 28

◆ SQLITE_TESTCTRL_RESERVE

#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */

◆ SQLITE_TESTCTRL_RESULT_INTREAL

#define SQLITE_TESTCTRL_RESULT_INTREAL 27

◆ SQLITE_TESTCTRL_SCRATCHMALLOC

#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */

◆ SQLITE_TESTCTRL_SEEK_COUNT

#define SQLITE_TESTCTRL_SEEK_COUNT 30

◆ SQLITE_TESTCTRL_SORTER_MMAP

#define SQLITE_TESTCTRL_SORTER_MMAP 24

◆ SQLITE_TESTCTRL_TRACEFLAGS

#define SQLITE_TESTCTRL_TRACEFLAGS 31

◆ SQLITE_TESTCTRL_TUNE

#define SQLITE_TESTCTRL_TUNE 32

◆ SQLITE_TESTCTRL_USELONGDOUBLE

#define SQLITE_TESTCTRL_USELONGDOUBLE 34 /* NOT USED */

◆ SQLITE_TESTCTRL_VDBE_COVERAGE

#define SQLITE_TESTCTRL_VDBE_COVERAGE 21

◆ SQLITE_TEXT

#define SQLITE_TEXT 3

◆ SQLITE_TOOBIG

#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */

◆ SQLITE_TRACE_CLOSE

#define SQLITE_TRACE_CLOSE 0x08

◆ SQLITE_TRACE_PROFILE

#define SQLITE_TRACE_PROFILE 0x02

◆ SQLITE_TRACE_ROW

#define SQLITE_TRACE_ROW 0x04

◆ SQLITE_TRACE_STMT

#define SQLITE_TRACE_STMT 0x01

◆ SQLITE_TRANSACTION

#define SQLITE_TRANSACTION 22 /* Operation NULL */

◆ SQLITE_TRANSIENT

#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

◆ SQLITE_TXN_NONE

#define SQLITE_TXN_NONE 0

◆ SQLITE_TXN_READ

#define SQLITE_TXN_READ 1

◆ SQLITE_TXN_WRITE

#define SQLITE_TXN_WRITE 2

◆ SQLITE_UPDATE

#define SQLITE_UPDATE 23 /* Table Name Column Name */

◆ SQLITE_UTF16

#define SQLITE_UTF16 4 /* Use native byte order */

◆ SQLITE_UTF16_ALIGNED

#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

◆ SQLITE_UTF16BE

#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */

◆ SQLITE_UTF16LE

#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */

◆ SQLITE_UTF8

#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */

◆ SQLITE_VERSION

#define SQLITE_VERSION "3.50.2"

◆ SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER 3050002

◆ SQLITE_VTAB_CONSTRAINT_SUPPORT

#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1

◆ SQLITE_VTAB_DIRECTONLY

#define SQLITE_VTAB_DIRECTONLY 3

◆ SQLITE_VTAB_INNOCUOUS

#define SQLITE_VTAB_INNOCUOUS 2

◆ SQLITE_VTAB_USES_ALL_SCHEMAS

#define SQLITE_VTAB_USES_ALL_SCHEMAS 4

◆ SQLITE_WARNING

#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */

◆ SQLITE_WARNING_AUTOINDEX

#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8))

◆ SQLITE_WIN32_DATA_DIRECTORY_TYPE

#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1

◆ SQLITE_WIN32_TEMP_DIRECTORY_TYPE

#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2

Typedef Documentation

◆ fts5_extension_function

typedef void(* fts5_extension_function) (const Fts5ExtensionApi *pApi, Fts5Context *pFts, sqlite3_context *pCtx, int nVal, sqlite3_value **apVal)

◆ sqlite3_callback

typedef int(* sqlite3_callback) (void *, int, char **, char **)

◆ sqlite3_destructor_type

typedef void(* sqlite3_destructor_type) (void *)

◆ sqlite3_filename

typedef const char* sqlite3_filename

◆ sqlite3_snapshot

typedef struct sqlite3_snapshot sqlite3_snapshot

◆ sqlite3_syscall_ptr

typedef void(* sqlite3_syscall_ptr) (void)

Function Documentation

◆ sqlite3_aggregate_context()

void * sqlite3_aggregate_context	(	sqlite3_context *	p,
		int	nBytes )

                                                                         {
  assert( p && p->pFunc && p->pFunc->xFinalize );
  assert( sqlite3_mutex_held(p->pOut->db->mutex) );
  testcase( nByte<0 );

References createAggContext(), sqlite3_value::db, sqlite3_value::flags, MEM_Agg, sqlite3::mutex, sqlite3_context::pFunc, sqlite3_context::pMem, sqlite3_context::pOut, sqlite3_mutex_held(), SQLITE_API, testcase, FuncDef::xFinalize, and sqlite3_value::z.

Here is the call graph for this function:

◆ sqlite3_aggregate_count()

int sqlite3_aggregate_count ( sqlite3_context * p )

References sqlite3_value::n, sqlite3_context::pFunc, sqlite3_context::pMem, SQLITE_API, and FuncDef::xFinalize.

◆ sqlite3_auto_extension()

int sqlite3_auto_extension ( void(* xEntryPoint )(void) )

 {
  int rc = SQLITE_OK;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( xInit==0 ) return SQLITE_MISUSE_BKPT;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ){
    return rc;
  }else
#endif
  {
    u32 i;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    for(i=0; i<wsdAutoext.nExt; i++){
      if( wsdAutoext.aExt[i]==xInit ) break;
    }
    if( i==wsdAutoext.nExt ){
      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
      void (**aNew)(void);
      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
      if( aNew==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        wsdAutoext.aExt = aNew;
        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
        wsdAutoext.nExt++;
      }

References sqlite3_initialize(), sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3_realloc64, sqlite3MutexAlloc(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_MUTEX_STATIC_MAIN, SQLITE_NOMEM_BKPT, SQLITE_OK, wsdAutoext, and wsdAutoextInit.

Here is the call graph for this function:

◆ sqlite3_autovacuum_pages()

int sqlite3_autovacuum_pages	(	sqlite3 *	db,
		unsigned	int)(void , const char *, unsigned int, unsigned int, unsigned int,
		void *	,
		void(*	)(void *) )

References SQLITE_API, and SQLITE_DEPRECATED.

◆ sqlite3_backup_finish()

int sqlite3_backup_finish ( sqlite3_backup * p )

                                                       {
  sqlite3_backup **pp;                 /* Ptr to head of pagers backup list */
  sqlite3 *pSrcDb;                     /* Source database connection */
  int rc;                              /* Value to return */
 
  /* Enter the mutexes */
  if( p==0 ) return SQLITE_OK;
  pSrcDb = p->pSrcDb;
  sqlite3_mutex_enter(pSrcDb->mutex);
  sqlite3BtreeEnter(p->pSrc);
  if( p->pDestDb ){
    sqlite3_mutex_enter(p->pDestDb->mutex);
  }
 
  /* Detach this backup from the source pager. */
  if( p->pDestDb ){
    p->pSrc->nBackup--;
  }
  if( p->isAttached ){
    pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
    assert( pp!=0 );
    while( *pp!=p ){
      pp = &(*pp)->pNext;
      assert( pp!=0 );
    }
    *pp = p->pNext;
  }
 
  /* If a transaction is still open on the Btree, roll it back. */
  sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0);
 
  /* Set the error code of the destination database handle. */
  rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
  if( p->pDestDb ){
    sqlite3Error(p->pDestDb, rc);
 
    /* Exit the mutexes and free the backup context structure. */
    sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
  }
  sqlite3BtreeLeave(p->pSrc);
  if( p->pDestDb ){
    /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
    ** call to sqlite3_backup_init() and is destroyed by a call to

◆ sqlite3_backup_init()

sqlite3_backup * sqlite3_backup_init	(	sqlite3 *	pDest,
		const char *	zDestName,
		sqlite3 *	pSource,
		const char *	zSourceName )

 {
  sqlite3_backup *p;                    /* Value to return */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  /* Lock the source database handle. The destination database
  ** handle is not locked in this routine, but it is locked in
  ** sqlite3_backup_step(). The user is required to ensure that no
  ** other thread accesses the destination handle for the duration
  ** of the backup operation.  Any attempt to use the destination
  ** database connection while a backup is in progress may cause
  ** a malfunction or a deadlock.
  */
  sqlite3_mutex_enter(pSrcDb->mutex);
  sqlite3_mutex_enter(pDestDb->mutex);
 
  if( pSrcDb==pDestDb ){
    sqlite3ErrorWithMsg(
        pDestDb, SQLITE_ERROR, "source and destination must be distinct"
    );
    p = 0;
  }else {
    /* Allocate space for a new sqlite3_backup object...
    ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
    ** call to sqlite3_backup_init() and is destroyed by a call to
    ** sqlite3_backup_finish(). */
    p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup));
    if( !p ){
      sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT);
    }
  }
 
  /* If the allocation succeeded, populate the new object. */
  if( p ){
    p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
    p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
    p->pDestDb = pDestDb;
    p->pSrcDb = pSrcDb;
    p->iNext = 1;
    p->isAttached = 0;
 
    if( 0==p->pSrc || 0==p->pDest
     || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
     ){
      /* One (or both) of the named databases did not exist or an OOM
      ** error was hit. Or there is a transaction open on the destination
      ** database. The error has already been written into the pDestDb
      ** handle. All that is left to do here is free the sqlite3_backup
      ** structure.  */
      sqlite3_free(p);
      p = 0;
    }
  }
  if( p ){
    p->pSrc->nBackup++;

References checkReadTransaction(), findBtree(), sqlite3_backup::iNext, sqlite3_backup::isAttached, sqlite3::mutex, Btree::nBackup, sqlite3_backup::pDest, sqlite3_backup::pDestDb, sqlite3_backup::pSrc, sqlite3_backup::pSrcDb, sqlite3_free, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3MallocZero(), sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, and SQLITE_OK.

Here is the call graph for this function:

◆ sqlite3_backup_pagecount()

int sqlite3_backup_pagecount ( sqlite3_backup * p )

                                                          {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ){

◆ sqlite3_backup_remaining()

int sqlite3_backup_remaining ( sqlite3_backup * p )

                                                          {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ){

◆ sqlite3_backup_step()

int sqlite3_backup_step	(	sqlite3_backup *	p,
		int	nPage )

                                                                {
  int rc;
  int destMode;       /* Destination journal mode */
  int pgszSrc = 0;    /* Source page size */
  int pgszDest = 0;   /* Destination page size */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(p->pSrcDb->mutex);
  sqlite3BtreeEnter(p->pSrc);
  if( p->pDestDb ){
    sqlite3_mutex_enter(p->pDestDb->mutex);
  }
 
  rc = p->rc;
  if( !isFatalError(rc) ){
    Pager * const pSrcPager = sqlite3BtreePager(p->pSrc);     /* Source pager */
    Pager * const pDestPager = sqlite3BtreePager(p->pDest);   /* Dest pager */
    int ii;                            /* Iterator variable */
    int nSrcPage = -1;                 /* Size of source db in pages */
    int bCloseTrans = 0;               /* True if src db requires unlocking */
 
    /* If the source pager is currently in a write-transaction, return
    ** SQLITE_BUSY immediately.
    */
    if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
      rc = SQLITE_BUSY;
    }else{
      rc = SQLITE_OK;
    }
 
    /* If there is no open read-transaction on the source database, open
    ** one now. If a transaction is opened here, then it will be closed
    ** before this function exits.
    */
    if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){
      rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0);
      bCloseTrans = 1;
    }
 
    /* If the destination database has not yet been locked (i.e. if this
    ** is the first call to backup_step() for the current backup operation),
    ** try to set its page size to the same as the source database. This
    ** is especially important on ZipVFS systems, as in that case it is
    ** not possible to create a database file that uses one page size by
    ** writing to it with another.  */
    if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){
      rc = SQLITE_NOMEM;
    }
 
    /* Lock the destination database, if it is not locked already. */
    if( SQLITE_OK==rc && p->bDestLocked==0
     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
                                                (int*)&p->iDestSchema))
    ){
      p->bDestLocked = 1;
    }
 
    /* Do not allow backup if the destination database is in WAL mode
    ** and the page sizes are different between source and destination */
    pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
    pgszDest = sqlite3BtreeGetPageSize(p->pDest);
    destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
    if( SQLITE_OK==rc
     && (destMode==PAGER_JOURNALMODE_WAL || sqlite3PagerIsMemdb(pDestPager))
     && pgszSrc!=pgszDest
    ){
      rc = SQLITE_READONLY;
    }
 
    /* Now that there is a read-lock on the source database, query the
    ** source pager for the number of pages in the database.
    */
    nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
    assert( nSrcPage>=0 );
    for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
      const Pgno iSrcPg = p->iNext;                 /* Source page number */
      if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
        DbPage *pSrcPg;                             /* Source page object */
        rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY);
        if( rc==SQLITE_OK ){
          rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);
          sqlite3PagerUnref(pSrcPg);
        }
      }
      p->iNext++;
    }
    if( rc==SQLITE_OK ){
      p->nPagecount = nSrcPage;
      p->nRemaining = nSrcPage+1-p->iNext;
      if( p->iNext>(Pgno)nSrcPage ){
        rc = SQLITE_DONE;
      }else if( !p->isAttached ){
        attachBackupObject(p);
      }
    }
 
    /* Update the schema version field in the destination database. This
    ** is to make sure that the schema-version really does change in
    ** the case where the source and destination databases have the
    ** same schema version.
    */
    if( rc==SQLITE_DONE ){
      if( nSrcPage==0 ){
        rc = sqlite3BtreeNewDb(p->pDest);
        nSrcPage = 1;
      }
      if( rc==SQLITE_OK || rc==SQLITE_DONE ){
        rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
      }
      if( rc==SQLITE_OK ){
        if( p->pDestDb ){
          sqlite3ResetAllSchemasOfConnection(p->pDestDb);
        }
        if( destMode==PAGER_JOURNALMODE_WAL ){
          rc = sqlite3BtreeSetVersion(p->pDest, 2);
        }
      }
      if( rc==SQLITE_OK ){
        int nDestTruncate;
        /* Set nDestTruncate to the final number of pages in the destination
        ** database. The complication here is that the destination page
        ** size may be different to the source page size.
        **
        ** If the source page size is smaller than the destination page size,
        ** round up. In this case the call to sqlite3OsTruncate() below will
        ** fix the size of the file. However it is important to call
        ** sqlite3PagerTruncateImage() here so that any pages in the
        ** destination file that lie beyond the nDestTruncate page mark are
        ** journalled by PagerCommitPhaseOne() before they are destroyed
        ** by the file truncation.
        */
        assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
        assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
        if( pgszSrc<pgszDest ){
          int ratio = pgszDest/pgszSrc;
          nDestTruncate = (nSrcPage+ratio-1)/ratio;
          if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
            nDestTruncate--;
          }
        }else{
          nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
        }
        assert( nDestTruncate>0 );
 
        if( pgszSrc<pgszDest ){
          /* If the source page-size is smaller than the destination page-size,
          ** two extra things may need to happen:
          **
          **   * The destination may need to be truncated, and
          **
          **   * Data stored on the pages immediately following the
          **     pending-byte page in the source database may need to be
          **     copied into the destination database.
          */
          const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
          sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
          Pgno iPg;
          int nDstPage;
          i64 iOff;
          i64 iEnd;
 
          assert( pFile );
          assert( nDestTruncate==0
              || (i64)nDestTruncate*(i64)pgszDest >= iSize || (
                nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
             && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
          ));
 
          /* This block ensures that all data required to recreate the original
          ** database has been stored in the journal for pDestPager and the
          ** journal synced to disk. So at this point we may safely modify
          ** the database file in any way, knowing that if a power failure
          ** occurs, the original database will be reconstructed from the
          ** journal file.  */
          sqlite3PagerPagecount(pDestPager, &nDstPage);
          for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){
            if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){
              DbPage *pPg;
              rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0);
              if( rc==SQLITE_OK ){
                rc = sqlite3PagerWrite(pPg);
                sqlite3PagerUnref(pPg);
              }
            }
          }
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1);
          }
 
          /* Write the extra pages and truncate the database file as required */
          iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
          for(
            iOff=PENDING_BYTE+pgszSrc;
            rc==SQLITE_OK && iOff<iEnd;
            iOff+=pgszSrc
          ){
            PgHdr *pSrcPg = 0;
            const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
            rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg, 0);
            if( rc==SQLITE_OK ){
              u8 *zData = sqlite3PagerGetData(pSrcPg);
              rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
            }
            sqlite3PagerUnref(pSrcPg);
          }
          if( rc==SQLITE_OK ){
            rc = backupTruncateFile(pFile, iSize);
          }
 
          /* Sync the database file to disk. */
          if( rc==SQLITE_OK ){
            rc = sqlite3PagerSync(pDestPager, 0);
          }
        }else{
          sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
          rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
        }
 
        /* Finish committing the transaction to the destination database. */
        if( SQLITE_OK==rc
         && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
        ){
          rc = SQLITE_DONE;
        }
      }
    }
 
    /* If bCloseTrans is true, then this function opened a read transaction
    ** on the source database. Close the read transaction here. There is
    ** no need to check the return values of the btree methods here, as
    ** "committing" a read-only transaction cannot fail.
    */
    if( bCloseTrans ){
      TESTONLY( int rc2 );
      TESTONLY( rc2  = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
      TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
      assert( rc2==SQLITE_OK );
    }
 
    if( rc==SQLITE_IOERR_NOMEM ){
      rc = SQLITE_NOMEM_BKPT;
    }
    p->rc = rc;
  }
  if( p->pDestDb ){

◆ sqlite3_bind_blob()

int sqlite3_bind_blob	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	n,
		void(*	xDel )(void *) )

◆ sqlite3_bind_blob64()

int sqlite3_bind_blob64	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		sqlite3_uint64	nData,
		void(*	xDel )(void *) )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( nData<0 ) return SQLITE_MISUSE_BKPT;
#endif
  return bindText(pStmt, i, zData, nData, xDel, 0);
}
SQLITE_API int sqlite3_bind_blob64(
  sqlite3_stmt *pStmt,
  int i,
  const void *zData,

References bindText(), and SQLITE_MISUSE_BKPT.

Here is the call graph for this function:

◆ sqlite3_bind_double()

int sqlite3_bind_double	(	sqlite3_stmt *	pStmt,
		int	i,
		double	rValue )

 {
  assert( xDel!=SQLITE_DYNAMIC );
  return bindText(pStmt, i, zData, nData, xDel, 0);
}
SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i-1));
  if( rc==SQLITE_OK ){

References bindText(), and SQLITE_DYNAMIC.

Here is the call graph for this function:

◆ sqlite3_bind_int()

int sqlite3_bind_int	(	sqlite3_stmt *	p,
		int	i,
		int	iValue )

◆ sqlite3_bind_int64()

int sqlite3_bind_int64	(	sqlite3_stmt *	pStmt,
		int	i,
		sqlite3_int64	iValue )

                                                                   {
  return sqlite3_bind_int64(p, i, (i64)iValue);
}
SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i-1));
  if( rc==SQLITE_OK ){

◆ sqlite3_bind_null()

int sqlite3_bind_null	(	sqlite3_stmt *	pStmt,
		int	i )

                                                            {
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
  rc = vdbeUnbind(p, (u32)(i-1));

◆ sqlite3_bind_parameter_count()

int sqlite3_bind_parameter_count ( sqlite3_stmt * pStmt )

◆ sqlite3_bind_parameter_index()

int sqlite3_bind_parameter_index	(	sqlite3_stmt *	pStmt,
		const char *	zName )

93378 {

References Vdbe::pVList, sqlite3VListNameToNum(), and SQLITE_PRIVATE.

Here is the call graph for this function:

◆ sqlite3_bind_parameter_name()

const char * sqlite3_bind_parameter_name	(	sqlite3_stmt *	pStmt,
		int	i )

References Vdbe::pVList, sqlite3VListNumToName(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_bind_pointer()

int sqlite3_bind_pointer	(	sqlite3_stmt *	pStmt,
		int	i,
		void *	pPtr,
		const char *	zPTtype,
		void(*	xDestructor )(void *) )

                     {
    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_pointer(
  sqlite3_stmt *pStmt,
  int i,
  void *pPtr,
  const char *zPTtype,
  void (*xDestructor)(void*)
){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
  rc = vdbeUnbind(p, (u32)(i-1));
  if( rc==SQLITE_OK ){
    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
    sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave, and SQLITE_OK.

◆ sqlite3_bind_text()

int sqlite3_bind_text	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		int	nData,
		void(*	xDel )(void *) )

                         {
    xDestructor(pPtr);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_text(
  sqlite3_stmt *pStmt,
  int i,

◆ sqlite3_bind_text16()

int sqlite3_bind_text16	(	sqlite3_stmt *	pStmt,
		int	i,
		const void *	zData,
		int	n,
		void(*	xDel )(void *) )

References SQLITE_UTF16, and SQLITE_UTF16NATIVE.

◆ sqlite3_bind_text64()

int sqlite3_bind_text64	(	sqlite3_stmt *	pStmt,
		int	i,
		const char *	zData,
		sqlite3_uint64	nData,
		void(*	xDel )(void *),
		unsigned char	encoding )

 {
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
}
SQLITE_API int sqlite3_bind_text64(
  sqlite3_stmt *pStmt,
  int i,
  const char *zData,
  sqlite3_uint64 nData,
  void (*xDel)(void*),
  unsigned char enc
){
  assert( xDel!=SQLITE_DYNAMIC );

References bindText(), and SQLITE_UTF8.

Here is the call graph for this function:

◆ sqlite3_bind_value()

int sqlite3_bind_value	(	sqlite3_stmt *	pStmt,
		int	i,
		const sqlite3_value *	pValue )

 {
  return bindText(pStmt, i, zData, n & ~(u64)1, xDel, SQLITE_UTF16NATIVE);
}
#endif /* SQLITE_OMIT_UTF16 */
SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
  int rc;
  switch( sqlite3_value_type((sqlite3_value*)pValue) ){
    case SQLITE_INTEGER: {
      rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
      break;
    }
    case SQLITE_FLOAT: {
      assert( pValue->flags & (MEM_Real|MEM_IntReal) );
      rc = sqlite3_bind_double(pStmt, i,
          (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i
      );
      break;
    }
    case SQLITE_BLOB: {
      if( pValue->flags & MEM_Zero ){
        rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
      }else{
        rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
      }
      break;
    }
    case SQLITE_TEXT: {
      rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                              pValue->enc);
      break;
    }
    default: {

References bindText(), and SQLITE_UTF16NATIVE.

Here is the call graph for this function:

◆ sqlite3_bind_zeroblob()

int sqlite3_bind_zeroblob	(	sqlite3_stmt *	pStmt,
		int	i,
		int	n )

                                                                       {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i-1));
  if( rc==SQLITE_OK ){
    assert( p!=0 && p->aVar!=0 && i>0 && i<=p->nVar ); /* tag-20240917-01 */
#ifndef SQLITE_OMIT_INCRBLOB
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
#else

◆ sqlite3_bind_zeroblob64()

int sqlite3_bind_zeroblob64	(	sqlite3_stmt *	pStmt,
		int	i,
		sqlite3_uint64	n )

                                                                                    {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( p==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(p->db->mutex);
  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
    rc = SQLITE_TOOBIG;
  }else{
    assert( (n & 0x7FFFFFFF)==n );

◆ sqlite3_blob_bytes()

int sqlite3_blob_bytes ( sqlite3_blob * pBlob )

References Incrblob::nByte, Incrblob::pStmt, and SQLITE_API.

◆ sqlite3_blob_close()

int sqlite3_blob_close ( sqlite3_blob * pBlob )

                                                      {
  Incrblob *p = (Incrblob *)pBlob;
  int rc;
  sqlite3 *db;
 
  if( p ){
    sqlite3_stmt *pStmt = p->pStmt;
    db = p->db;
    sqlite3_mutex_enter(db->mutex);
    sqlite3DbFree(db, p);
    sqlite3_mutex_leave(db->mutex);

◆ sqlite3_blob_open()

int sqlite3_blob_open	(	sqlite3 *	db,
		const char *	zDb,
		const char *	zTable,
		const char *	zColumn,
		sqlite3_int64	iRow,
		int	flags,
		sqlite3_blob **	ppBlob )

 {
  int nAttempt = 0;
  int iCol;               /* Index of zColumn in row-record */
  int rc = SQLITE_OK;
  char *zErr = 0;
  Table *pTab;
  Incrblob *pBlob = 0;
  int iDb;
  Parse sParse;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppBlob==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  *ppBlob = 0;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zTable==0 || zColumn==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  wrFlag = !!wrFlag;                /* wrFlag = (wrFlag ? 1 : 0); */
 
  sqlite3_mutex_enter(db->mutex);
 
  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
  while(1){
    sqlite3ParseObjectInit(&sParse,db);
    if( !pBlob ) goto blob_open_out;
    sqlite3DbFree(db, zErr);
    zErr = 0;
 
    sqlite3BtreeEnterAll(db);
    pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb);
    if( pTab && IsVirtual(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable);
    }
    if( pTab && !HasRowid(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable);
    }
    if( pTab && (pTab->tabFlags&TF_HasGenerated)!=0 ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open table with generated columns: %s",
                      zTable);
    }
#ifndef SQLITE_OMIT_VIEW
    if( pTab && IsView(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
    }
#endif
    if( pTab==0
     || ((iDb = sqlite3SchemaToIndex(db, pTab->pSchema))==1 &&
         sqlite3OpenTempDatabase(&sParse))
    ){
      if( sParse.zErrMsg ){
        sqlite3DbFree(db, zErr);
        zErr = sParse.zErrMsg;
        sParse.zErrMsg = 0;
      }
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }
    pBlob->pTab = pTab;
    pBlob->zDb = db->aDb[iDb].zDbSName;
 
    /* Now search pTab for the exact column. */
    iCol = sqlite3ColumnIndex(pTab, zColumn);
    if( iCol<0 ){
      sqlite3DbFree(db, zErr);
      zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }
 
    /* If the value is being opened for writing, check that the
    ** column is not indexed, and that it is not part of a foreign key.
    */
    if( wrFlag ){
      const char *zFault = 0;
      Index *pIdx;
#ifndef SQLITE_OMIT_FOREIGN_KEY
      if( db->flags&SQLITE_ForeignKeys ){
        /* Check that the column is not part of an FK child key definition. It
        ** is not necessary to check if it is part of a parent key, as parent
        ** key columns must be indexed. The check below will pick up this
        ** case.  */
        FKey *pFKey;
        assert( IsOrdinaryTable(pTab) );
        for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
          int j;
          for(j=0; j<pFKey->nCol; j++){
            if( pFKey->aCol[j].iFrom==iCol ){
              zFault = "foreign key";
            }
          }
        }
      }
#endif
      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
        int j;
        for(j=0; j<pIdx->nKeyCol; j++){
          /* FIXME: Be smarter about indexes that use expressions */
          if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
            zFault = "indexed";
          }
        }
      }
      if( zFault ){
        sqlite3DbFree(db, zErr);
        zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
        rc = SQLITE_ERROR;
        sqlite3BtreeLeaveAll(db);
        goto blob_open_out;
      }
    }
 
    pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse);
    assert( pBlob->pStmt || db->mallocFailed );
    if( pBlob->pStmt ){
 
      /* This VDBE program seeks a btree cursor to the identified
      ** db/table/row entry. The reason for using a vdbe program instead
      ** of writing code to use the b-tree layer directly is that the
      ** vdbe program will take advantage of the various transaction,
      ** locking and error handling infrastructure built into the vdbe.
      **
      ** After seeking the cursor, the vdbe executes an OP_ResultRow.
      ** Code external to the Vdbe then "borrows" the b-tree cursor and
      ** uses it to implement the blob_read(), blob_write() and
      ** blob_bytes() functions.
      **
      ** The sqlite3_blob_close() function finalizes the vdbe program,
      ** which closes the b-tree cursor and (possibly) commits the
      ** transaction.
      */
      static const int iLn = VDBE_OFFSET_LINENO(2);
      static const VdbeOpList openBlob[] = {
        {OP_TableLock,      0, 0, 0},  /* 0: Acquire a read or write lock */
        {OP_OpenRead,       0, 0, 0},  /* 1: Open a cursor */
        /* blobSeekToRow() will initialize r[1] to the desired rowid */
        {OP_NotExists,      0, 5, 1},  /* 2: Seek the cursor to rowid=r[1] */
        {OP_Column,         0, 0, 1},  /* 3  */
        {OP_ResultRow,      1, 0, 0},  /* 4  */
        {OP_Halt,           0, 0, 0},  /* 5  */
      };
      Vdbe *v = (Vdbe *)pBlob->pStmt;
      VdbeOp *aOp;
 
      sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
                           pTab->pSchema->schema_cookie,
                           pTab->pSchema->iGeneration);
      sqlite3VdbeChangeP5(v, 1);
      assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
      aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
 
      /* Make sure a mutex is held on the table to be accessed */
      sqlite3VdbeUsesBtree(v, iDb);
 
      if( db->mallocFailed==0 ){
        assert( aOp!=0 );
        /* Configure the OP_TableLock instruction */
#ifdef SQLITE_OMIT_SHARED_CACHE
        aOp[0].opcode = OP_Noop;
#else
        aOp[0].p1 = iDb;
        aOp[0].p2 = pTab->tnum;
        aOp[0].p3 = wrFlag;
        sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
      }
      if( db->mallocFailed==0 ){
#endif
 
        /* Remove either the OP_OpenWrite or OpenRead. Set the P2
        ** parameter of the other to pTab->tnum.  */
        if( wrFlag ) aOp[1].opcode = OP_OpenWrite;
        aOp[1].p2 = pTab->tnum;
        aOp[1].p3 = iDb;
 
        /* Configure the number of columns. Configure the cursor to
        ** think that the table has one more column than it really
        ** does. An OP_Column to retrieve this imaginary column will
        ** always return an SQL NULL. This is useful because it means
        ** we can invoke OP_Column to fill in the vdbe cursors type
        ** and offset cache without causing any IO.
        */
        aOp[1].p4type = P4_INT32;
        aOp[1].p4.i = pTab->nCol+1;
        aOp[3].p2 = pTab->nCol;
 
        sParse.nVar = 0;
        sParse.nMem = 1;
        sParse.nTab = 1;
        sqlite3VdbeMakeReady(v, &sParse);
      }
    }
 
    pBlob->iCol = iCol;
    pBlob->db = db;
    sqlite3BtreeLeaveAll(db);
    if( db->mallocFailed ){
      goto blob_open_out;
    }
    rc = blobSeekToRow(pBlob, iRow, &zErr);
    if( (++nAttempt)>=SQLITE_MAX_SCHEMA_RETRY || rc!=SQLITE_SCHEMA ) break;
    sqlite3ParseObjectReset(&sParse);
  }
 
blob_open_out:
  if( rc==SQLITE_OK && db->mallocFailed==0 ){
    *ppBlob = (sqlite3_blob *)pBlob;
  }else{
    if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
    sqlite3DbFree(db, pBlob);
  }
  sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : (char*)0), zErr);

◆ sqlite3_blob_read()

int sqlite3_blob_read	(	sqlite3_blob *	pBlob,
		void *	Z,
		int	N,
		int	iOffset )

◆ sqlite3_blob_reopen()

int sqlite3_blob_reopen	(	sqlite3_blob *	pBlob,
		sqlite3_int64	iRow )

                                                                           {
  int rc;
  Incrblob *p = (Incrblob *)pBlob;
  sqlite3 *db;
 
  if( p==0 ) return SQLITE_MISUSE_BKPT;
  db = p->db;
  sqlite3_mutex_enter(db->mutex);
 
  if( p->pStmt==0 ){
    /* If there is no statement handle, then the blob-handle has
    ** already been invalidated. Return SQLITE_ABORT in this case.
    */
    rc = SQLITE_ABORT;
  }else{
    char *zErr;
    ((Vdbe*)p->pStmt)->rc = SQLITE_OK;
    rc = blobSeekToRow(p, iRow, &zErr);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : (char*)0), zErr);
      sqlite3DbFree(db, zErr);
    }
    assert( rc!=SQLITE_SCHEMA );
  }

References blobSeekToRow(), Incrblob::db, sqlite3::mutex, Incrblob::pStmt, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3ApiExit(), sqlite3DbFree(), sqlite3ErrorWithMsg(), SQLITE_ABORT, SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_OK, and SQLITE_SCHEMA.

Here is the call graph for this function:

◆ sqlite3_blob_write()

int sqlite3_blob_write	(	sqlite3_blob *	pBlob,
		const void *	z,
		int	n,
		int	iOffset )

References sqlite3BtreePayloadChecked().

Here is the call graph for this function:

◆ sqlite3_busy_handler()

int sqlite3_busy_handler	(	sqlite3 *	db,
		int(*	xBusy )(void *, int),
		void *	pArg )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->busyHandler.xBusyHandler = xBusy;
  db->busyHandler.pBusyArg = pArg;
  db->busyHandler.nBusy = 0;

◆ sqlite3_busy_timeout()

int sqlite3_busy_timeout	(	sqlite3 *	db,
		int	ms )

                                                        {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( ms>0 ){
    sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback,
                             (void*)db);
    db->busyTimeout = ms;
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT

References sqlite3_busy_handler, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, and sqliteDefaultBusyCallback().

Here is the call graph for this function:

◆ sqlite3_cancel_auto_extension()

int sqlite3_cancel_auto_extension ( void(* xEntryPoint )(void) )

 {
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  int i;
  int n = 0;
  wsdAutoextInit;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( xInit==0 ) return 0;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=(int)wsdAutoext.nExt-1; i>=0; i--){
    if( wsdAutoext.aExt[i]==xInit ){
      wsdAutoext.nExt--;
      wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt];
      n++;

References sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3MutexAlloc(), SQLITE_API, SQLITE_MUTEX_STATIC_MAIN, wsdAutoext, and wsdAutoextInit.

Here is the call graph for this function:

◆ sqlite3_changes()

int sqlite3_changes ( sqlite3 * db )

                                 {
    (void)SQLITE_MISUSE_BKPT;
    return 0;

References SQLITE_MISUSE_BKPT.

◆ sqlite3_changes64()

sqlite3_int64 sqlite3_changes64 ( sqlite3 * db )

183733 {

183734#ifdef SQLITE_ENABLE_API_ARMOR

◆ sqlite3_clear_bindings()

int sqlite3_clear_bindings ( sqlite3_stmt * pStmt )

                                                          {
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pStmt==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
#if SQLITE_THREADSAFE
  mutex = p->db->mutex;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
    sqlite3VdbeMemRelease(&p->aVar[i]);
    p->aVar[i].flags = MEM_Null;
  }
  assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );

◆ sqlite3_close()

int sqlite3_close ( sqlite3 * db )

◆ sqlite3_close_v2()

int sqlite3_close_v2 ( sqlite3 * db )

References sqlite3Close(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_collation_needed()

int sqlite3_collation_needed	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void(*	xCollNeeded )(void , sqlite3 , int eTextRep, const char *) )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif

◆ sqlite3_collation_needed16()

int sqlite3_collation_needed16	(	sqlite3 *	db,
		void *	pCollNeededArg,
		void(*	xCollNeeded16 )(void , sqlite3 , int eTextRep, const void *) )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif

◆ sqlite3_column_blob()

const void * sqlite3_column_blob	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                      {
  const void *val;
  val = sqlite3_value_blob( columnMem(pStmt,i) );
  /* Even though there is no encoding conversion, value_blob() might

◆ sqlite3_column_bytes()

int sqlite3_column_bytes	(	sqlite3_stmt *	pStmt,
		int	iCol )

◆ sqlite3_column_bytes16()

int sqlite3_column_bytes16	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                               {
  int val = sqlite3_value_bytes( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_count()

int sqlite3_column_count ( sqlite3_stmt * pStmt )

◆ sqlite3_column_database_name()

const char * sqlite3_column_database_name	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_database_name16()

const void * sqlite3_column_database_name16	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_decltype()

const char * sqlite3_column_decltype	(	sqlite3_stmt *	pStmt,
		int	N )

◆ sqlite3_column_decltype16()

const void * sqlite3_column_decltype16	(	sqlite3_stmt *	pStmt,
		int	N )

93014 {

References COLNAME_DECLTYPE, columnName(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_column_double()

double sqlite3_column_double	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                 {
  int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_int()

int sqlite3_column_int	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                   {
  double val = sqlite3_value_double( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_int64()

sqlite3_int64 sqlite3_column_int64	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                             {
  int val = sqlite3_value_int( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_name()

const char * sqlite3_column_name	(	sqlite3_stmt *	pStmt,
		int	N )

◆ sqlite3_column_name16()

const void * sqlite3_column_name16	(	sqlite3_stmt *	pStmt,
		int	N )

92991 {

References COLNAME_NAME, columnName(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_column_origin_name()

const char * sqlite3_column_origin_name	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_origin_name16()

const void * sqlite3_column_origin_name16	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_table_name()

const char * sqlite3_column_table_name	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_table_name16()

const void * sqlite3_column_table_name16	(	sqlite3_stmt *	,
		int	)

References SQLITE_API.

◆ sqlite3_column_text()

const unsigned char * sqlite3_column_text	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                        {
  sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;

◆ sqlite3_column_text16()

const void * sqlite3_column_text16	(	sqlite3_stmt *	pStmt,
		int	iCol )

References MEM_Ephem.

◆ sqlite3_column_type()

int sqlite3_column_type	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                        {
  const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;
}

References columnMallocFailure(), columnMem(), sqlite3_value_text16, and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_column_value()

sqlite3_value * sqlite3_column_value	(	sqlite3_stmt *	pStmt,
		int	iCol )

                                                                               {
  const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
  columnMallocFailure(pStmt);
  return val;
}
SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
  Mem *pOut = columnMem(pStmt, i);
  if( pOut->flags&MEM_Static ){

◆ sqlite3_commit_hook()

void * sqlite3_commit_hook	(	sqlite3 *	db,
		int(*	xCallback )(void *),
		void *	pArg )

 {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif

References sqlite3::mutex, sqlite3::pCommitArg, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, and sqlite3::xCommitCallback.

Here is the call graph for this function:

◆ sqlite3_compileoption_get()

const char * sqlite3_compileoption_get ( int N )

187721 {

187722 int nOpt;

◆ sqlite3_compileoption_used()

int sqlite3_compileoption_used ( const char * zOptName )

                                                               {
  int i, n;
  int nOpt;
  const char **azCompileOpt;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zOptName==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  azCompileOpt = sqlite3CompileOptions(&nOpt);
 
  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);
 
  /* Since nOpt is normally in single digits, a linear search is
  ** adequate. No need for a binary search. */
  for(i=0; i<nOpt; i++){
    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0

References sqlite3CompileOptions(), sqlite3IsIdChar(), sqlite3Strlen30(), sqlite3StrNICmp, SQLITE_API, and SQLITE_MISUSE_BKPT.

Here is the call graph for this function:

◆ sqlite3_complete()

int sqlite3_complete ( const char * sql )

                                                 {
  u8 state = 0;   /* Current state, using numbers defined in header comment */
  u8 token;       /* Value of the next token */
 
#ifndef SQLITE_OMIT_TRIGGER
  /* A complex statement machine used to detect the end of a CREATE TRIGGER
  ** statement.  This is the normal case.
  */
  static const u8 trans[8][8] = {
                     /* Token:                                                */
     /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
     /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
     /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
     /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
     /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
     /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
     /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
     /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
     /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
  };
#else
  /* If triggers are not supported by this compile then the statement machine
  ** used to detect the end of a statement is much simpler
  */
  static const u8 trans[3][3] = {
                     /* Token:           */
     /* State:       **  SEMI  WS  OTHER */
     /* 0 INVALID: */ {    1,  0,     2, },
     /* 1   START: */ {    1,  1,     2, },
     /* 2  NORMAL: */ {    1,  2,     2, },
  };
#endif /* SQLITE_OMIT_TRIGGER */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zSql==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  while( *zSql ){
    switch( *zSql ){
      case ';': {  /* A semicolon */
        token = tkSEMI;
        break;
      }
      case ' ':
      case '\r':
      case '\t':
      case '\n':
      case '\f': {  /* White space is ignored */
        token = tkWS;
        break;
      }
      case '/': {   /* C-style comments */
        if( zSql[1]!='*' ){
          token = tkOTHER;
          break;
        }
        zSql += 2;
        while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
        if( zSql[0]==0 ) return 0;
        zSql++;
        token = tkWS;
        break;
      }
      case '-': {   /* SQL-style comments from "--" to end of line */
        if( zSql[1]!='-' ){
          token = tkOTHER;
          break;
        }
        while( *zSql && *zSql!='\n' ){ zSql++; }
        if( *zSql==0 ) return state==1;
        token = tkWS;
        break;
      }
      case '[': {   /* Microsoft-style identifiers in [...] */
        zSql++;
        while( *zSql && *zSql!=']' ){ zSql++; }
        if( *zSql==0 ) return 0;
        token = tkOTHER;
        break;
      }
      case '`':     /* Grave-accent quoted symbols used by MySQL */
      case '"':     /* single- and double-quoted strings */
      case '\'': {
        int c = *zSql;
        zSql++;
        while( *zSql && *zSql!=c ){ zSql++; }
        if( *zSql==0 ) return 0;
        token = tkOTHER;
        break;
      }
      default: {
#ifdef SQLITE_EBCDIC
        unsigned char c;
#endif
        if( IdChar((u8)*zSql) ){
          /* Keywords and unquoted identifiers */
          int nId;
          for(nId=1; IdChar(zSql[nId]); nId++){}
#ifdef SQLITE_OMIT_TRIGGER
          token = tkOTHER;
#else
          switch( *zSql ){
            case 'c': case 'C': {
              if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
                token = tkCREATE;
              }else{
                token = tkOTHER;
              }
              break;
            }
            case 't': case 'T': {
              if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
                token = tkTRIGGER;
              }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
                token = tkTEMP;
              }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
                token = tkTEMP;
              }else{
                token = tkOTHER;
              }
              break;
            }
            case 'e':  case 'E': {
              if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
                token = tkEND;
              }else
#ifndef SQLITE_OMIT_EXPLAIN
              if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
                token = tkEXPLAIN;
              }else
#endif
              {
                token = tkOTHER;
              }
              break;
            }
            default: {
              token = tkOTHER;
              break;
            }
          }
#endif /* SQLITE_OMIT_TRIGGER */
          zSql += nId-1;
        }else{
          /* Operators and special symbols */
          token = tkOTHER;
        }
        break;

References c, IdChar, sqlite3StrNICmp, SQLITE_API, SQLITE_MISUSE_BKPT, tkCREATE, tkEND, tkEXPLAIN, tkOTHER, tkSEMI, tkTEMP, tkTRIGGER, and tkWS.

◆ sqlite3_complete16()

int sqlite3_complete16 ( const void * sql )

                                                   {
  sqlite3_value *pVal;
  char const *zSql8;
  int rc;
 
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  pVal = sqlite3ValueNew(0);
  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
  if( zSql8 ){

References sqlite3_complete, sqlite3_initialize(), sqlite3ValueFree(), sqlite3ValueNew(), sqlite3ValueSetStr(), sqlite3ValueText(), SQLITE_API, SQLITE_NOMEM_BKPT, SQLITE_STATIC, SQLITE_UTF16NATIVE, and SQLITE_UTF8.

Here is the call graph for this function:

◆ sqlite3_config()

int sqlite3_config	(	int	op,
			... )

                                          {
  va_list ap;
  int rc = SQLITE_OK;
 
  /* sqlite3_config() normally returns SQLITE_MISUSE if it is invoked while
  ** the SQLite library is in use.  Except, a few selected opcodes
  ** are allowed.
  */
  if( sqlite3GlobalConfig.isInit ){
    static const u64 mAnytimeConfigOption = 0
       | MASKBIT64( SQLITE_CONFIG_LOG )
       | MASKBIT64( SQLITE_CONFIG_PCACHE_HDRSZ )
    ;
    if( op<0 || op>63 || (MASKBIT64(op) & mAnytimeConfigOption)==0 ){
      return SQLITE_MISUSE_BKPT;
    }
    testcase( op==SQLITE_CONFIG_LOG );
    testcase( op==SQLITE_CONFIG_PCACHE_HDRSZ );
  }
 
  va_start(ap, op);
  switch( op ){
 
    /* Mutex configuration options are only available in a threadsafe
    ** compile.
    */
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0  /* IMP: R-54466-46756 */
    case SQLITE_CONFIG_SINGLETHREAD: {
      /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
      ** Single-thread. */
      sqlite3GlobalConfig.bCoreMutex = 0;  /* Disable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
    case SQLITE_CONFIG_MULTITHREAD: {
      /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
      ** Multi-thread. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
    case SQLITE_CONFIG_SERIALIZED: {
      /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
      ** Serialized. */
      sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
      sqlite3GlobalConfig.bFullMutex = 1;  /* Enable mutex on connections */
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
    case SQLITE_CONFIG_MUTEX: {
      /* Specify an alternative mutex implementation */
      sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
      break;
    }
#endif
#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
    case SQLITE_CONFIG_GETMUTEX: {
      /* Retrieve the current mutex implementation */
      *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
      break;
    }
#endif
 
    case SQLITE_CONFIG_MALLOC: {
      /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The argument specifies alternative
      ** low-level memory allocation routines to be used in place of the memory
      ** allocation routines built into SQLite. */
      sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
      break;
    }
    case SQLITE_CONFIG_GETMALLOC: {
      /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
      ** single argument which is a pointer to an instance of the
      ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
      ** filled with the currently defined memory allocation routines. */
      if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
      *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
      break;
    }
    case SQLITE_CONFIG_MEMSTATUS: {
      assert( !sqlite3GlobalConfig.isInit );  /* Cannot change at runtime */
      /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
      ** single argument of type int, interpreted as a boolean, which enables
      ** or disables the collection of memory allocation statistics. */
      sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_SMALL_MALLOC: {
      sqlite3GlobalConfig.bSmallMalloc = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PAGECACHE: {
      /* EVIDENCE-OF: R-18761-36601 There are three arguments to
      ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
      ** the size of each page cache line (sz), and the number of cache lines
      ** (N). */
      sqlite3GlobalConfig.pPage = va_arg(ap, void*);
      sqlite3GlobalConfig.szPage = va_arg(ap, int);
      sqlite3GlobalConfig.nPage = va_arg(ap, int);
      break;
    }
    case SQLITE_CONFIG_PCACHE_HDRSZ: {
      /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
      ** a single parameter which is a pointer to an integer and writes into
      ** that integer the number of extra bytes per page required for each page
      ** in SQLITE_CONFIG_PAGECACHE. */
      *va_arg(ap, int*) =
          sqlite3HeaderSizeBtree() +
          sqlite3HeaderSizePcache() +
          sqlite3HeaderSizePcache1();
      break;
    }
 
    case SQLITE_CONFIG_PCACHE: {
      /* no-op */
      break;
    }
    case SQLITE_CONFIG_GETPCACHE: {
      /* now an error */
      rc = SQLITE_ERROR;
      break;
    }
 
    case SQLITE_CONFIG_PCACHE2: {
      /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. This object specifies the interface to a custom page cache
      ** implementation. */
      sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
      break;
    }
    case SQLITE_CONFIG_GETPCACHE2: {
      /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
      ** single argument which is a pointer to an sqlite3_pcache_methods2
      ** object. SQLite copies of the current page cache implementation into
      ** that object. */
      if( sqlite3GlobalConfig.pcache2.xInit==0 ){
        sqlite3PCacheSetDefault();
      }
      *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
      break;
    }
 
/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
    case SQLITE_CONFIG_HEAP: {
      /* EVIDENCE-OF: R-19854-42126 There are three arguments to
      ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
      ** number of bytes in the memory buffer, and the minimum allocation size.
      */
      sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      sqlite3GlobalConfig.mnReq = va_arg(ap, int);
 
      if( sqlite3GlobalConfig.mnReq<1 ){
        sqlite3GlobalConfig.mnReq = 1;
      }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
        /* cap min request size at 2^12 */
        sqlite3GlobalConfig.mnReq = (1<<12);
      }
 
      if( sqlite3GlobalConfig.pHeap==0 ){
        /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
        ** is NULL, then SQLite reverts to using its default memory allocator
        ** (the system malloc() implementation), undoing any prior invocation of
        ** SQLITE_CONFIG_MALLOC.
        **
        ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
        ** revert to its default implementation when sqlite3_initialize() is run
        */
        memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
      }else{
        /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
        ** alternative memory allocator is engaged to handle all of SQLites
        ** memory allocation needs. */
#ifdef SQLITE_ENABLE_MEMSYS3
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
#endif
#ifdef SQLITE_ENABLE_MEMSYS5
        sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
#endif
      }
      break;
    }
#endif
 
    case SQLITE_CONFIG_LOOKASIDE: {
      sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
      sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
      break;
    }
 
    /* Record a pointer to the logger function and its first argument.
    ** The default is NULL.  Logging is disabled if the function pointer is
    ** NULL.
    */
    case SQLITE_CONFIG_LOG: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
      */
      typedef void(*LOGFUNC_t)(void*,int,const char*);
      LOGFUNC_t xLog = va_arg(ap, LOGFUNC_t);
      void *pLogArg = va_arg(ap, void*);
      AtomicStore(&sqlite3GlobalConfig.xLog, xLog);
      AtomicStore(&sqlite3GlobalConfig.pLogArg, pLogArg);
      break;
    }
 
    /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
    ** can be changed at start-time using the
    ** sqlite3_config(SQLITE_CONFIG_URI,1) or
    ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
    */
    case SQLITE_CONFIG_URI: {
      /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
      ** argument of type int. If non-zero, then URI handling is globally
      ** enabled. If the parameter is zero, then URI handling is globally
      ** disabled. */
      int bOpenUri = va_arg(ap, int);
      AtomicStore(&sqlite3GlobalConfig.bOpenUri, bOpenUri);
      break;
    }
 
    case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
      /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
      ** option takes a single integer argument which is interpreted as a
      ** boolean in order to enable or disable the use of covering indices for
      ** full table scans in the query optimizer. */
      sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
      break;
    }
 
#ifdef SQLITE_ENABLE_SQLLOG
    case SQLITE_CONFIG_SQLLOG: {
      typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
      sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
      sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
      break;
    }
#endif
 
    case SQLITE_CONFIG_MMAP_SIZE: {
      /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
      ** integer (sqlite3_int64) values that are the default mmap size limit
      ** (the default setting for PRAGMA mmap_size) and the maximum allowed
      ** mmap size limit. */
      sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
      sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
      /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
      ** negative, then that argument is changed to its compile-time default.
      **
      ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
      ** silently truncated if necessary so that it does not exceed the
      ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
      ** compile-time option.
      */
      if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
        mxMmap = SQLITE_MAX_MMAP_SIZE;
      }
      if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
      if( szMmap>mxMmap) szMmap = mxMmap;
      sqlite3GlobalConfig.mxMmap = mxMmap;
      sqlite3GlobalConfig.szMmap = szMmap;
      break;
    }
 
#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
    case SQLITE_CONFIG_WIN32_HEAPSIZE: {
      /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
      ** unsigned integer value that specifies the maximum size of the created
      ** heap. */
      sqlite3GlobalConfig.nHeap = va_arg(ap, int);
      break;
    }
#endif
 
    case SQLITE_CONFIG_PMASZ: {
      sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
      break;
    }
 
    case SQLITE_CONFIG_STMTJRNL_SPILL: {
      sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int);
      break;
    }
 
#ifdef SQLITE_ENABLE_SORTER_REFERENCES
    case SQLITE_CONFIG_SORTERREF_SIZE: {
      int iVal = va_arg(ap, int);
      if( iVal<0 ){
        iVal = SQLITE_DEFAULT_SORTERREF_SIZE;
      }
      sqlite3GlobalConfig.szSorterRef = (u32)iVal;
      break;
    }
#endif /* SQLITE_ENABLE_SORTER_REFERENCES */
 
#ifndef SQLITE_OMIT_DESERIALIZE
    case SQLITE_CONFIG_MEMDB_MAXSIZE: {
      sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
      break;
    }
#endif /* SQLITE_OMIT_DESERIALIZE */
 
    case SQLITE_CONFIG_ROWID_IN_VIEW: {
      int *pVal = va_arg(ap,int*);
#ifdef SQLITE_ALLOW_ROWID_IN_VIEW
      if( 0==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = TF_NoVisibleRowid;
      if( 1==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = 0;
      *pVal = (sqlite3GlobalConfig.mNoVisibleRowid==0);
#else
      *pVal = 0;
#endif
      break;
    }
 
    default: {

References AtomicStore, MASKBIT64, sqlite3GlobalConfig, sqlite3HeaderSizeBtree(), sqlite3HeaderSizePcache(), sqlite3HeaderSizePcache1(), sqlite3MemSetDefault(), sqlite3PCacheSetDefault(), SQLITE_API, SQLITE_CONFIG_COVERING_INDEX_SCAN, SQLITE_CONFIG_GETMALLOC, SQLITE_CONFIG_GETMUTEX, SQLITE_CONFIG_GETPCACHE, SQLITE_CONFIG_GETPCACHE2, SQLITE_CONFIG_HEAP, SQLITE_CONFIG_LOG, SQLITE_CONFIG_LOOKASIDE, SQLITE_CONFIG_MALLOC, SQLITE_CONFIG_MEMDB_MAXSIZE, SQLITE_CONFIG_MEMSTATUS, SQLITE_CONFIG_MMAP_SIZE, SQLITE_CONFIG_MULTITHREAD, SQLITE_CONFIG_MUTEX, SQLITE_CONFIG_PAGECACHE, SQLITE_CONFIG_PCACHE, SQLITE_CONFIG_PCACHE2, SQLITE_CONFIG_PCACHE_HDRSZ, SQLITE_CONFIG_PMASZ, SQLITE_CONFIG_ROWID_IN_VIEW, SQLITE_CONFIG_SERIALIZED, SQLITE_CONFIG_SINGLETHREAD, SQLITE_CONFIG_SMALL_MALLOC, SQLITE_CONFIG_SORTERREF_SIZE, SQLITE_CONFIG_SQLLOG, SQLITE_CONFIG_STMTJRNL_SPILL, SQLITE_CONFIG_URI, SQLITE_CONFIG_WIN32_HEAPSIZE, SQLITE_DEFAULT_MMAP_SIZE, SQLITE_DEFAULT_SORTERREF_SIZE, SQLITE_ERROR, SQLITE_MAX_MMAP_SIZE, SQLITE_MISUSE_BKPT, SQLITE_OK, testcase, and TF_NoVisibleRowid.

Referenced by main(), main_init(), sqlite3MemSetDefault(), sqlite3MemTraceActivate(), sqlite3MemTraceDeactivate(), sqlite3PcacheTraceActivate(), sqlite3PcacheTraceDeactivate(), and verify_uninitialized().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite3_context_db_handle()

sqlite3 * sqlite3_context_db_handle ( sqlite3_context * p )

                    : R-46798-50301 The sqlite3_context_db_handle() interface
** returns a copy of the pointer to the database connection (the 1st
** parameter) of the sqlite3_create_function() and
** sqlite3_create_function16() routines that originally registered the
** application defined function.
*/
SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
#ifdef SQLITE_ENABLE_API_ARMOR

References sqlite3_value::db, sqlite3_context::pOut, and SQLITE_API.

◆ sqlite3_create_collation()

int sqlite3_create_collation	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int(*	xCompare )(void , int, const void , int, const void *) )

◆ sqlite3_create_collation16()

int sqlite3_create_collation16	(	sqlite3 *	db,
		const void *	zName,
		int	eTextRep,
		void *	pArg,
		int(*	xCompare )(void , int, const void , int, const void *) )

 {
  int rc = SQLITE_OK;
  char *zName8;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
  if( zName8 ){

◆ sqlite3_create_collation_v2()

int sqlite3_create_collation_v2	(	sqlite3 *	db,
		const char *	zName,
		int	eTextRep,
		void *	pArg,
		int(*	xCompare )(void , int, const void , int, const void *),
		void(*	xDestroy )(void *) )

 {
  return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
}
 
/*
** Register a new collation sequence with the database handle db.
*/
SQLITE_API int sqlite3_create_collation_v2(
  sqlite3* db,
  const char *zName,
  int enc,
  void* pCtx,
  int(*xCompare)(void*,int,const void*,int,const void*),
  void(*xDel)(void*)
){
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif

References sqlite3_create_collation_v2.

◆ sqlite3_create_filename()

sqlite3_filename sqlite3_create_filename	(	const char *	zDatabase,
		const char *	zJournal,
		const char *	zWal,
		int	nParam,
		const char **	azParam )

 {
  sqlite3_int64 nByte;
  int i;
  char *pResult, *p;
  nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10;
  for(i=0; i<nParam*2; i++){
    nByte += strlen(azParam[i])+1;
  }
  pResult = p = sqlite3_malloc64( nByte );
  if( p==0 ) return 0;
  memset(p, 0, 4);
  p += 4;
  p = appendText(p, zDatabase);
  for(i=0; i<nParam*2; i++){
    p = appendText(p, azParam[i]);
  }
  *(p++) = 0;

References appendText(), sqlite3_malloc64, and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_create_function()

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 *) )

◆ sqlite3_create_function16()

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 *) )

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
                                    xFinal, xValue, xInverse, xDestroy);
}
 
#ifndef SQLITE_OMIT_UTF16
SQLITE_API int sqlite3_create_function16(
  sqlite3 *db,
  const void *zFunctionName,
  int nArg,
  int eTextRep,
  void *p,
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*)
){
  int rc;
  char *zFunc8;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );

References createFunctionApi().

Here is the call graph for this function:

◆ sqlite3_create_function_v2()

int sqlite3_create_function_v2	(	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 *),
		void(*	xDestroy )(void *) )

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
                                    xFinal, 0, 0, 0);
}
SQLITE_API int sqlite3_create_function_v2(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),

References createFunctionApi().

Here is the call graph for this function:

◆ sqlite3_create_module()

int sqlite3_create_module	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData )

◆ sqlite3_create_module_v2()

int sqlite3_create_module_v2	(	sqlite3 *	db,
		const char *	zName,
		const sqlite3_module *	p,
		void *	pClientData,
		void(*	xDestroy )(void *) )

◆ sqlite3_create_window_function()

int sqlite3_create_window_function	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void(*	xStep )(sqlite3_context , int, sqlite3_value *),
		void(*	xFinal )(sqlite3_context *),
		void(*	xValue )(sqlite3_context *),
		void(*	xInverse )(sqlite3_context , int, sqlite3_value *),
		void(*	xDestroy )(void *) )

 {
  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
                                    xFinal, 0, 0, xDestroy);
}
SQLITE_API int sqlite3_create_window_function(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
  void (*xFinal)(sqlite3_context*),

References createFunctionApi().

Here is the call graph for this function:

◆ sqlite3_data_count()

int sqlite3_data_count ( sqlite3_stmt * pStmt )

◆ sqlite3_database_file_object()

sqlite3_file * sqlite3_database_file_object ( const char * zName )

                                                                        {
  Pager *pPager;
  const char *p;
  while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
    zName--;

References EIGHT_BYTE_ALIGNMENT, Pager::fd, and SQLITE_API.

◆ sqlite3_db_cacheflush()

int sqlite3_db_cacheflush ( sqlite3 * db )

                                                 {
  int i;
  int rc = SQLITE_OK;
  int bSeenBusy = 0;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( pBt && sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){
      Pager *pPager = sqlite3BtreePager(pBt);
      rc = sqlite3PagerFlush(pPager);
      if( rc==SQLITE_BUSY ){
        bSeenBusy = 1;
        rc = SQLITE_OK;

References SQLITE_OK.

◆ sqlite3_db_config()

int sqlite3_db_config	(	sqlite3 *	db,
		int	op,
			... )

                                                     : rc);
}
 
/*
** Configuration settings for an individual database connection
*/
SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
  va_list ap;
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  va_start(ap, op);
  switch( op ){
    case SQLITE_DBCONFIG_MAINDBNAME: {
      /* IMP: R-06824-28531 */
      /* IMP: R-36257-52125 */
      db->aDb[0].zDbSName = va_arg(ap,char*);
      rc = SQLITE_OK;
      break;
    }
    case SQLITE_DBCONFIG_LOOKASIDE: {
      void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
      int sz = va_arg(ap, int);       /* IMP: R-47871-25994 */
      int cnt = va_arg(ap, int);      /* IMP: R-04460-53386 */
      rc = setupLookaside(db, pBuf, sz, cnt);
      break;
    }
    default: {
      static const struct {
        int op;      /* The opcode */
        u64 mask;    /* Mask of the bit in sqlite3.flags to set/clear */
      } aFlagOp[] = {
        { SQLITE_DBCONFIG_ENABLE_FKEY,           SQLITE_ForeignKeys    },
        { SQLITE_DBCONFIG_ENABLE_TRIGGER,        SQLITE_EnableTrigger  },
        { SQLITE_DBCONFIG_ENABLE_VIEW,           SQLITE_EnableView     },
        { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer  },
        { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension  },
        { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,      SQLITE_NoCkptOnClose  },
        { SQLITE_DBCONFIG_ENABLE_QPSG,           SQLITE_EnableQPSG     },
        { SQLITE_DBCONFIG_TRIGGER_EQP,           SQLITE_TriggerEQP     },
        { SQLITE_DBCONFIG_RESET_DATABASE,        SQLITE_ResetDatabase  },
        { SQLITE_DBCONFIG_DEFENSIVE,             SQLITE_Defensive      },
        { SQLITE_DBCONFIG_WRITABLE_SCHEMA,       SQLITE_WriteSchema|
                                                 SQLITE_NoSchemaError  },
        { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,    SQLITE_LegacyAlter    },
        { SQLITE_DBCONFIG_DQS_DDL,               SQLITE_DqsDDL         },
        { SQLITE_DBCONFIG_DQS_DML,               SQLITE_DqsDML         },
        { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,    SQLITE_LegacyFileFmt  },
        { SQLITE_DBCONFIG_TRUSTED_SCHEMA,        SQLITE_TrustedSchema  },
        { SQLITE_DBCONFIG_STMT_SCANSTATUS,       SQLITE_StmtScanStatus },
        { SQLITE_DBCONFIG_REVERSE_SCANORDER,     SQLITE_ReverseOrder   },
        { SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE,  SQLITE_AttachCreate   },
        { SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE,   SQLITE_AttachWrite    },
        { SQLITE_DBCONFIG_ENABLE_COMMENTS,       SQLITE_Comments       },
      };
      unsigned int i;
      rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
      for(i=0; i<ArraySize(aFlagOp); i++){
        if( aFlagOp[i].op==op ){
          int onoff = va_arg(ap, int);
          int *pRes = va_arg(ap, int*);
          u64 oldFlags = db->flags;
          if( onoff>0 ){
            db->flags |= aFlagOp[i].mask;
          }else if( onoff==0 ){
            db->flags &= ~(u64)aFlagOp[i].mask;
          }
          if( oldFlags!=db->flags ){
            sqlite3ExpirePreparedStatements(db, 0);
          }
          if( pRes ){
            *pRes = (db->flags & aFlagOp[i].mask)!=0;
          }
          rc = SQLITE_OK;
          break;
        }
      }

References SQLITE_BUSY, and SQLITE_OK.

◆ sqlite3_db_filename()

sqlite3_filename sqlite3_db_filename	(	sqlite3 *	db,
		const char *	zDbName )

                                                                            {
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

◆ sqlite3_db_handle()

sqlite3 * sqlite3_db_handle ( sqlite3_stmt * pStmt )

References SQLITE_API.

◆ sqlite3_db_mutex()

sqlite3_mutex * sqlite3_db_mutex ( sqlite3 * db )

183483 {

183484#ifdef SQLITE_ENABLE_API_ARMOR

References SQLITE_OK.

◆ sqlite3_db_name()

const char * sqlite3_db_name	(	sqlite3 *	db,
		int	N )

                   : db->aDb[iDb].pBt;
}
 
/*
** Return the name of the N-th database schema.  Return NULL if N is out
** of range.
*/
SQLITE_API const char *sqlite3_db_name(sqlite3 *db, int N){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }

◆ sqlite3_db_readonly()

int sqlite3_db_readonly	(	sqlite3 *	db,
		const char *	zDbName )

                                            : 0;
}
 
/*
** Return 1 if database is read-only or 0 if read/write.  Return -1 if
** no such database exists.
*/
SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

◆ sqlite3_db_release_memory()

int sqlite3_db_release_memory ( sqlite3 * db )

                                                     {
  int i;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      Pager *pPager = sqlite3BtreePager(pBt);

◆ sqlite3_db_status()

int sqlite3_db_status	(	sqlite3 *	db,
		int	op,
		int *	pCur,
		int *	pHiwtr,
		int	resetFlg )

 {
  int rc = SQLITE_OK;   /* Return code */
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  switch( op ){
    case SQLITE_DBSTATUS_LOOKASIDE_USED: {
      *pCurrent = sqlite3LookasideUsed(db, pHighwater);
      if( resetFlag ){
        LookasideSlot *p = db->lookaside.pFree;
        if( p ){
          while( p->pNext ) p = p->pNext;
          p->pNext = db->lookaside.pInit;
          db->lookaside.pInit = db->lookaside.pFree;
          db->lookaside.pFree = 0;
        }
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
        p = db->lookaside.pSmallFree;
        if( p ){
          while( p->pNext ) p = p->pNext;
          p->pNext = db->lookaside.pSmallInit;
          db->lookaside.pSmallInit = db->lookaside.pSmallFree;
          db->lookaside.pSmallFree = 0;
        }
#endif
      }
      break;
    }
 
    case SQLITE_DBSTATUS_LOOKASIDE_HIT:
    case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
    case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
      testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
      assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
      assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
      *pCurrent = 0;
      *pHighwater = (int)db->lookaside.anStat[op-SQLITE_DBSTATUS_LOOKASIDE_HIT];
      if( resetFlag ){
        db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
      }
      break;
    }
 
    /*
    ** Return an approximation for the amount of memory currently used
    ** by all pagers associated with the given database connection.  The
    ** highwater mark is meaningless and is returned as zero.
    */
    case SQLITE_DBSTATUS_CACHE_USED_SHARED:
    case SQLITE_DBSTATUS_CACHE_USED: {
      int totalUsed = 0;
      int i;
      sqlite3BtreeEnterAll(db);
      for(i=0; i<db->nDb; i++){
        Btree *pBt = db->aDb[i].pBt;
        if( pBt ){
          Pager *pPager = sqlite3BtreePager(pBt);
          int nByte = sqlite3PagerMemUsed(pPager);
          if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){
            nByte = nByte / sqlite3BtreeConnectionCount(pBt);
          }
          totalUsed += nByte;
        }
      }
      sqlite3BtreeLeaveAll(db);
      *pCurrent = totalUsed;
      *pHighwater = 0;
      break;
    }
 
    /*
    ** *pCurrent gets an accurate estimate of the amount of memory used
    ** to store the schema for all databases (main, temp, and any ATTACHed
    ** databases.  *pHighwater is set to zero.
    */
    case SQLITE_DBSTATUS_SCHEMA_USED: {
      int i;                      /* Used to iterate through schemas */
      int nByte = 0;              /* Used to accumulate return value */
 
      sqlite3BtreeEnterAll(db);
      db->pnBytesFreed = &nByte;
      assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );
      db->lookaside.pEnd = db->lookaside.pStart;
      for(i=0; i<db->nDb; i++){
        Schema *pSchema = db->aDb[i].pSchema;
        if( ALWAYS(pSchema!=0) ){
          HashElem *p;
 
          nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
              pSchema->tblHash.count
            + pSchema->trigHash.count
            + pSchema->idxHash.count
            + pSchema->fkeyHash.count
          );
          nByte += sqlite3_msize(pSchema->tblHash.ht);
          nByte += sqlite3_msize(pSchema->trigHash.ht);
          nByte += sqlite3_msize(pSchema->idxHash.ht);
          nByte += sqlite3_msize(pSchema->fkeyHash.ht);
 
          for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
            sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
          }
          for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
            sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
          }
        }
      }
      db->pnBytesFreed = 0;
      db->lookaside.pEnd = db->lookaside.pTrueEnd;
      sqlite3BtreeLeaveAll(db);
 
      *pHighwater = 0;
      *pCurrent = nByte;
      break;
    }
 
    /*
    ** *pCurrent gets an accurate estimate of the amount of memory used
    ** to store all prepared statements.
    ** *pHighwater is set to zero.
    */
    case SQLITE_DBSTATUS_STMT_USED: {
      struct Vdbe *pVdbe;         /* Used to iterate through VMs */
      int nByte = 0;              /* Used to accumulate return value */
 
      db->pnBytesFreed = &nByte;
      assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );
      db->lookaside.pEnd = db->lookaside.pStart;
      for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pVNext){
        sqlite3VdbeDelete(pVdbe);
      }
      db->lookaside.pEnd = db->lookaside.pTrueEnd;
      db->pnBytesFreed = 0;
 
      *pHighwater = 0;  /* IMP: R-64479-57858 */
      *pCurrent = nByte;
 
      break;
    }
 
    /*
    ** Set *pCurrent to the total cache hits or misses encountered by all
    ** pagers the database handle is connected to. *pHighwater is always set
    ** to zero.
    */
    case SQLITE_DBSTATUS_CACHE_SPILL:
      op = SQLITE_DBSTATUS_CACHE_WRITE+1;
      /* no break */ deliberate_fall_through
    case SQLITE_DBSTATUS_CACHE_HIT:
    case SQLITE_DBSTATUS_CACHE_MISS:
    case SQLITE_DBSTATUS_CACHE_WRITE:{
      int i;
      u64 nRet = 0;
      assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
      assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 );
 
      for(i=0; i<db->nDb; i++){
        if( db->aDb[i].pBt ){
          Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
          sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
        }
      }
      *pHighwater = 0; /* IMP: R-42420-56072 */
                       /* IMP: R-54100-20147 */
                       /* IMP: R-29431-39229 */
      *pCurrent = (int)nRet & 0x7fffffff;
      break;
    }
 
    /* Set *pCurrent to non-zero if there are unresolved deferred foreign
    ** key constraints.  Set *pCurrent to zero if all foreign key constraints
    ** have been satisfied.  The *pHighwater is always set to zero.
    */
    case SQLITE_DBSTATUS_DEFERRED_FKS: {
      *pHighwater = 0;  /* IMP: R-11967-56545 */
      *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
      break;
    }
 
    default: {
      rc = SQLITE_ERROR;

◆ sqlite3_declare_vtab()

int sqlite3_declare_vtab	(	sqlite3 *	db,
		const char *	zSQL )

                                                                          {
  VtabCtx *pCtx;
  int rc = SQLITE_OK;
  Table *pTab;
  Parse sParse;
  int initBusy;
  int i;
  const unsigned char *z;
  static const u8 aKeyword[] = { TK_CREATE, TK_TABLE, 0 };
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
 
  /* Verify that the first two keywords in the CREATE TABLE statement
  ** really are "CREATE" and "TABLE".  If this is not the case, then
  ** sqlite3_declare_vtab() is being misused.
  */
  z = (const unsigned char*)zCreateTable;
  for(i=0; aKeyword[i]; i++){
    int tokenType = 0;
    do{
      z += sqlite3GetToken(z, &tokenType);
    }while( tokenType==TK_SPACE || tokenType==TK_COMMENT );
    if( tokenType!=aKeyword[i] ){
      sqlite3ErrorWithMsg(db, SQLITE_ERROR, "syntax error");
      return SQLITE_ERROR;
    }
  }
 
  sqlite3_mutex_enter(db->mutex);
  pCtx = db->pVtabCtx;
  if( !pCtx || pCtx->bDeclared ){
    sqlite3Error(db, SQLITE_MISUSE_BKPT);
    sqlite3_mutex_leave(db->mutex);
    return SQLITE_MISUSE_BKPT;
  }
 
  pTab = pCtx->pTab;
  assert( IsVirtual(pTab) );
 
  sqlite3ParseObjectInit(&sParse, db);
  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
  sParse.disableTriggers = 1;
  /* We should never be able to reach this point while loading the
  ** schema.  Nevertheless, defend against that (turn off db->init.busy)
  ** in case a bug arises. */
  assert( db->init.busy==0 );
  initBusy = db->init.busy;
  db->init.busy = 0;
  sParse.nQueryLoop = 1;
  if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) ){
    assert( sParse.pNewTable!=0 );
    assert( !db->mallocFailed );
    assert( IsOrdinaryTable(sParse.pNewTable) );
    assert( sParse.zErrMsg==0 );
    if( !pTab->aCol ){
      Table *pNew = sParse.pNewTable;
      Index *pIdx;
      pTab->aCol = pNew->aCol;
      assert( IsOrdinaryTable(pNew) );
      sqlite3ExprListDelete(db, pNew->u.tab.pDfltList);
      pTab->nNVCol = pTab->nCol = pNew->nCol;
      pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid);
      pNew->nCol = 0;
      pNew->aCol = 0;
      assert( pTab->pIndex==0 );
      assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 );
      if( !HasRowid(pNew)
       && pCtx->pVTable->pMod->pModule->xUpdate!=0
       && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1
      ){
        /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
        ** or else must have a single-column PRIMARY KEY */
        rc = SQLITE_ERROR;
      }
      pIdx = pNew->pIndex;
      if( pIdx ){
        assert( pIdx->pNext==0 );
        pTab->pIndex = pIdx;
        pNew->pIndex = 0;
        pIdx->pTable = pTab;
      }
    }
    pCtx->bDeclared = 1;
  }else{
    sqlite3ErrorWithMsg(db, SQLITE_ERROR,
          (sParse.zErrMsg ? "%s" : 0), sParse.zErrMsg);
    sqlite3DbFree(db, sParse.zErrMsg);
    rc = SQLITE_ERROR;
  }
  sParse.eParseMode = PARSE_MODE_NORMAL;
 
  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  sqlite3ParseObjectReset(&sParse);
  db->init.busy = initBusy;

References Table::aCol, VtabCtx::bDeclared, sqlite3::sqlite3InitInfo::busy, Parse::disableTriggers, Parse::eParseMode, HasRowid, sqlite3::init, IsOrdinaryTable, IsVirtual, sqlite3::mallocFailed, sqlite3::mutex, Table::nCol, Table::nNVCol, Parse::nQueryLoop, PARSE_MODE_DECLARE_VTAB, PARSE_MODE_NORMAL, Table::pIndex, VTable::pMod, Module::pModule, Parse::pNewTable, Index::pNext, VtabCtx::pTab, Index::pTable, Parse::pVdbe, sqlite3::pVtabCtx, VtabCtx::pVTable, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3ApiExit(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3ExprListDelete(), sqlite3GetToken(), sqlite3ParseObjectInit(), sqlite3ParseObjectReset(), sqlite3PrimaryKeyIndex(), sqlite3RunParser(), sqlite3SafetyCheckOk(), sqlite3VdbeFinalize(), SQLITE_API, SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_OK, Table::tabFlags, TF_NoVisibleRowid, TF_WithoutRowid, TK_COMMENT, TK_CREATE, TK_SPACE, TK_TABLE, Table::u, sqlite3_module::xUpdate, and Parse::zErrMsg.

Here is the call graph for this function:

◆ sqlite3_deserialize()

int sqlite3_deserialize	(	sqlite3 *	db,
		const char *	zSchema,
		unsigned char *	pData,
		sqlite3_int64	szDb,
		sqlite3_int64	szBuf,
		unsigned	mFlags )

 {
  MemFile *p;
  char *zSql;
  sqlite3_stmt *pStmt = 0;
  int rc;
  int iDb;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
  if( szDb<0 ) return SQLITE_MISUSE_BKPT;
  if( szBuf<0 ) return SQLITE_MISUSE_BKPT;
#endif
 
  sqlite3_mutex_enter(db->mutex);
  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
  iDb = sqlite3FindDbName(db, zSchema);
  testcase( iDb==1 );
  if( iDb<2 && iDb!=0 ){
    rc = SQLITE_ERROR;
    goto end_deserialize;
  }
  zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema);
  if( zSql==0 ){
    rc = SQLITE_NOMEM;
  }else{
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
    sqlite3_free(zSql);
  }
  if( rc ) goto end_deserialize;
  db->init.iDb = (u8)iDb;
  db->init.reopenMemdb = 1;
  rc = sqlite3_step(pStmt);
  db->init.reopenMemdb = 0;
  if( rc!=SQLITE_DONE ){
    rc = SQLITE_ERROR;
    goto end_deserialize;
  }
  p = memdbFromDbSchema(db, zSchema);
  if( p==0 ){
    rc = SQLITE_ERROR;
  }else{
    MemStore *pStore = p->pStore;
    pStore->aData = pData;
    pData = 0;
    pStore->sz = szDb;
    pStore->szAlloc = szBuf;
    pStore->szMax = szBuf;
    if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
      pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
    }
    pStore->mFlags = mFlags;
    rc = SQLITE_OK;
  }
 
end_deserialize:
  sqlite3_finalize(pStmt);

◆ sqlite3_drop_modules()

int sqlite3_drop_modules	(	sqlite3 *	db,
		const char **	azKeep )

                                                                      {
  HashElem *pThis, *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
    Module *pMod = (Module*)sqliteHashData(pThis);
    pNext = sqliteHashNext(pThis);
    if( azNames ){
      int ii;
      for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}

◆ sqlite3_enable_load_extension()

int sqlite3_enable_load_extension	(	sqlite3 *	db,
		int	onoff )

                                                                    {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;

Referenced by open_db().

Here is the caller graph for this function:

◆ sqlite3_enable_shared_cache()

int sqlite3_enable_shared_cache ( int enable )

References sqlite3GlobalConfig, SQLITE_API, and SQLITE_OK.

◆ sqlite3_errcode()

int sqlite3_errcode ( sqlite3 * db )

185373 {

185374 if( db && !sqlite3SafetyCheckSickOrOk(db) ){

sqlite3SafetyCheckSickOrOk

static int sqlite3SafetyCheckSickOrOk(sqlite3 *)

Definition sqlite3.c:37068

◆ sqlite3_errmsg()

const char * sqlite3_errmsg ( sqlite3 * db )

                                                  {
  const char *z;
  if( !db ){
    return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }else{
    testcase( db->pErr==0 );
    z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
    assert( !db->mallocFailed );

◆ sqlite3_errmsg16()

const void * sqlite3_errmsg16 ( sqlite3 * db )

                                                    {
  static const u16 outOfMem[] = {
    'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
  };
  static const u16 misuse[] = {
    'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ',
    'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
    'm', 'i', 's', 'u', 's', 'e', 0
  };
 
  const void *z;
  if( !db ){
    return (void *)outOfMem;
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return (void *)misuse;
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = (void *)outOfMem;
  }else{
    z = sqlite3_value_text16(db->pErr);
    if( z==0 ){
      sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
      z = sqlite3_value_text16(db->pErr);
    }
    /* A malloc() may have failed within the call to sqlite3_value_text16()
    ** above. If this is the case, then the db->mallocFailed flag needs to
    ** be cleared before returning. Do this directly, instead of via

◆ sqlite3_error_offset()

int sqlite3_error_offset ( sqlite3 * db )

185316 {

185317 int iOffset = -1;

◆ sqlite3_errstr()

const char * sqlite3_errstr ( int rc )

◆ sqlite3_exec()

int sqlite3_exec	(	sqlite3 *	db,
		const char *	sql,
		int(*	callback )(void , int, char , char *),
		void *	pArg,
		char **	errmsg )

 {
  int rc = SQLITE_OK;         /* Return code */
  const char *zLeftover;      /* Tail of unprocessed SQL */
  sqlite3_stmt *pStmt = 0;    /* The current SQL statement */
  char **azCols = 0;          /* Names of result columns */
  int callbackIsInit;         /* True if callback data is initialized */
 
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  if( zSql==0 ) zSql = "";
 
  sqlite3_mutex_enter(db->mutex);
  sqlite3Error(db, SQLITE_OK);
  while( rc==SQLITE_OK && zSql[0] ){
    int nCol = 0;
    char **azVals = 0;
 
    pStmt = 0;
    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
    assert( rc==SQLITE_OK || pStmt==0 );
    if( rc!=SQLITE_OK ){
      continue;
    }
    if( !pStmt ){
      /* this happens for a comment or white-space */
      zSql = zLeftover;
      continue;
    }
    callbackIsInit = 0;
 
    while( 1 ){
      int i;
      rc = sqlite3_step(pStmt);
 
      /* Invoke the callback function if required */
      if( xCallback && (SQLITE_ROW==rc ||
          (SQLITE_DONE==rc && !callbackIsInit
                           && db->flags&SQLITE_NullCallback)) ){
        if( !callbackIsInit ){
          nCol = sqlite3_column_count(pStmt);
          azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
          if( azCols==0 ){
            goto exec_out;
          }
          for(i=0; i<nCol; i++){
            azCols[i] = (char *)sqlite3_column_name(pStmt, i);
            /* sqlite3VdbeSetColName() installs column names as UTF8
            ** strings so there is no way for sqlite3_column_name() to fail. */
            assert( azCols[i]!=0 );
          }
          callbackIsInit = 1;
        }
        if( rc==SQLITE_ROW ){
          azVals = &azCols[nCol];
          for(i=0; i<nCol; i++){
            azVals[i] = (char *)sqlite3_column_text(pStmt, i);
            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
              sqlite3OomFault(db);
              goto exec_out;
            }
          }
          azVals[i] = 0;
        }
        if( xCallback(pArg, nCol, azVals, azCols) ){
          /* EVIDENCE-OF: R-38229-40159 If the callback function to
          ** sqlite3_exec() returns non-zero, then sqlite3_exec() will
          ** return SQLITE_ABORT. */
          rc = SQLITE_ABORT;
          sqlite3VdbeFinalize((Vdbe *)pStmt);
          pStmt = 0;
          sqlite3Error(db, SQLITE_ABORT);
          goto exec_out;
        }
      }
 
      if( rc!=SQLITE_ROW ){
        rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
        pStmt = 0;
        zSql = zLeftover;
        while( sqlite3Isspace(zSql[0]) ) zSql++;
        break;
      }
    }
 
    sqlite3DbFree(db, azCols);
    azCols = 0;
  }
 
exec_out:
  if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
  sqlite3DbFree(db, azCols);
 
  rc = sqlite3ApiExit(db, rc);
  if( rc!=SQLITE_OK && pzErrMsg ){
    *pzErrMsg = sqlite3DbStrDup(0, sqlite3_errmsg(db));
    if( *pzErrMsg==0 ){
      rc = SQLITE_NOMEM_BKPT;
      sqlite3Error(db, SQLITE_NOMEM);
    }
  }else if( pzErrMsg ){
    *pzErrMsg = 0;

References sqlite3::errMask, sqlite3::flags, sqlite3::mutex, sqlite3_column_count, sqlite3_column_name, sqlite3_column_text, sqlite3_column_type, sqlite3_errmsg, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3_prepare_v2, sqlite3_step, sqlite3ApiExit(), sqlite3DbFree(), sqlite3DbMallocRaw(), sqlite3DbStrDup(), sqlite3Error(), sqlite3Isspace, sqlite3OomFault(), sqlite3SafetyCheckOk(), sqlite3VdbeFinalize(), SQLITE_ABORT, SQLITE_API, SQLITE_DONE, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_NULL, SQLITE_NullCallback, SQLITE_OK, and SQLITE_ROW.

Here is the call graph for this function:

◆ sqlite3_expanded_sql()

char * sqlite3_expanded_sql ( sqlite3_stmt * pStmt )

                                                          {
#ifdef SQLITE_OMIT_TRACE
  return 0;
#else
  char *z = 0;
  const char *zSql = sqlite3_sql(pStmt);
  if( zSql ){
    Vdbe *p = (Vdbe *)pStmt;
    sqlite3_mutex_enter(p->db->mutex);

References Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3_sql, sqlite3VdbeExpandSql(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_expired()

int sqlite3_expired ( sqlite3_stmt * pStmt )

References Vdbe::expired, and SQLITE_API.

◆ sqlite3_extended_errcode()

int sqlite3_extended_errcode ( sqlite3 * db )

                               {
    return SQLITE_NOMEM_BKPT;
  }
  return db->errCode & db->errMask;
}
SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){
  if( db && !sqlite3SafetyCheckSickOrOk(db) ){

References SQLITE_MISUSE_BKPT.

◆ sqlite3_extended_result_codes()

int sqlite3_extended_result_codes	(	sqlite3 *	db,
		int	onoff )

                                      : 1000*ms)/1000);
  return rc;
}
 
/*
** Enable or disable the extended result codes.
*/
SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
#ifdef SQLITE_ENABLE_API_ARMOR

◆ sqlite3_file_control()

int sqlite3_file_control	(	sqlite3 *	db,
		const char *	zDbName,
		int	op,
		void *	pArg )

                                                                                         {
  int rc = SQLITE_ERROR;
  Btree *pBtree;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  pBtree = sqlite3DbNameToBtree(db, zDbName);
  if( pBtree ){
    Pager *pPager;
    sqlite3_file *fd;
    sqlite3BtreeEnter(pBtree);
    pPager = sqlite3BtreePager(pBtree);
    assert( pPager!=0 );
    fd = sqlite3PagerFile(pPager);
    assert( fd!=0 );
    if( op==SQLITE_FCNTL_FILE_POINTER ){
      *(sqlite3_file**)pArg = fd;
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_VFS_POINTER ){
      *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
      *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_DATA_VERSION ){
      *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){
      int iNew = *(int*)pArg;
      *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree);
      if( iNew>=0 && iNew<=255 ){
        sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0);
      }
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_RESET_CACHE ){
      sqlite3BtreeClearCache(pBtree);
      rc = SQLITE_OK;
    }else{
      int nSave = db->busyHandler.nBusy;
      rc = sqlite3OsFileControl(fd, op, pArg);

References SQLITE_OK.

◆ sqlite3_filename_database()

const char * sqlite3_filename_database ( sqlite3_filename zFilename )

◆ sqlite3_filename_journal()

const char * sqlite3_filename_journal ( sqlite3_filename zFilename )

                                                                       {
  if( zFilename==0 ) return 0;
  return databaseName(zFilename);
}
SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){
  if( zFilename==0 ) return 0;
  zFilename = databaseName(zFilename);

References databaseName(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_filename_wal()

const char * sqlite3_filename_wal ( sqlite3_filename zFilename )

                                            {
    zFilename += sqlite3Strlen30(zFilename) + 1;
    zFilename += sqlite3Strlen30(zFilename) + 1;
  }
  return zFilename + 1;
}
SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){
#ifdef SQLITE_OMIT_WAL

References sqlite3Strlen30().

Here is the call graph for this function:

◆ sqlite3_finalize()

int sqlite3_finalize ( sqlite3_stmt * pStmt )

                                                    {
  int rc;
  if( pStmt==0 ){
    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
    ** pointer is a harmless no-op. */
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    assert( v->eVdbeState>=VDBE_READY_STATE );
    rc = sqlite3VdbeReset(v);

References checkProfileCallback, Vdbe::db, Vdbe::eVdbeState, sqlite3::mutex, sqlite3_mutex_enter, sqlite3ApiExit(), sqlite3LeaveMutexAndCloseZombie(), sqlite3VdbeDelete(), sqlite3VdbeReset(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_OK, VDBE_READY_STATE, and vdbeSafety().

Here is the call graph for this function:

◆ sqlite3_free()

void sqlite3_free ( void * p )

                                     {
  if( p==0 ) return;  /* IMP: R-49053-54554 */
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
  if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
    sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
    sqlite3GlobalConfig.m.xFree(p);

◆ sqlite3_free_filename()

void sqlite3_free_filename ( sqlite3_filename p )

◆ sqlite3_free_table()

void sqlite3_free_table ( char ** result )

 {
  if( azResult ){
    int i, n;
    azResult--;

◆ sqlite3_get_autocommit()

int sqlite3_get_autocommit ( sqlite3 * db )

186480 {

186481#ifdef SQLITE_ENABLE_API_ARMOR

References sqlite3::autoCommit, sqlite3SafetyCheckOk(), SQLITE_API, and SQLITE_MISUSE_BKPT.

Here is the call graph for this function:

◆ sqlite3_get_auxdata()

void * sqlite3_get_auxdata	(	sqlite3_context *	pCtx,
		int	N )

                        :  If iArg is negative then access a cache of
** auxiliary data pointers that is available to all functions within a
** single prepared statement.  The iArg values must match.
*/
SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
  AuxData *pAuxData;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return 0;
#endif
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#if SQLITE_ENABLE_STAT4
  if( pCtx->pVdbe==0 ) return 0;
#else
  assert( pCtx->pVdbe!=0 );
#endif
  for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){

References sqlite3_value::db, AuxData::iAuxArg, AuxData::iAuxOp, sqlite3_context::iOp, sqlite3::mutex, AuxData::pAux, Vdbe::pAuxData, AuxData::pNextAux, sqlite3_context::pOut, sqlite3_context::pVdbe, sqlite3_mutex_held(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_get_clientdata()

void * sqlite3_get_clientdata	(	sqlite3 *	db,
		const char *	zName )

                                                                       {
  DbClientData *p;
  sqlite3_mutex_enter(db->mutex);
  for(p=db->pDbData; p; p=p->pNext){
    if( strcmp(p->zName, zName)==0 ){
      void *pResult = p->pData;

References SQLITE_OK.

◆ sqlite3_get_table()

int sqlite3_get_table	(	sqlite3 *	db,
		const char *	zSql,
		char ***	pazResult,
		int *	pnRow,
		int *	pnColumn,
		char **	pzErrmsg )

 {
  int rc;
  TabResult res;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *pazResult = 0;
  if( pnColumn ) *pnColumn = 0;
  if( pnRow ) *pnRow = 0;
  if( pzErrMsg ) *pzErrMsg = 0;
  res.zErrMsg = 0;
  res.nRow = 0;
  res.nColumn = 0;
  res.nData = 1;
  res.nAlloc = 20;
  res.rc = SQLITE_OK;
  res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc );
  if( res.azResult==0 ){
     db->errCode = SQLITE_NOMEM;
     return SQLITE_NOMEM_BKPT;
  }
  res.azResult[0] = 0;
  rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
  assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
  res.azResult[0] = SQLITE_INT_TO_PTR(res.nData);
  if( (rc&0xff)==SQLITE_ABORT ){
    sqlite3_free_table(&res.azResult[1]);
    if( res.zErrMsg ){
      if( pzErrMsg ){
        sqlite3_free(*pzErrMsg);
        *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
      }
      sqlite3_free(res.zErrMsg);
    }
    db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
    return res.rc;
  }
  sqlite3_free(res.zErrMsg);
  if( rc!=SQLITE_OK ){
    sqlite3_free_table(&res.azResult[1]);
    return rc;
  }
  if( res.nAlloc>res.nData ){
    char **azNew;
    azNew = sqlite3Realloc( res.azResult, sizeof(char*)*res.nData );
    if( azNew==0 ){
      sqlite3_free_table(&res.azResult[1]);
      db->errCode = SQLITE_NOMEM;
      return SQLITE_NOMEM_BKPT;
    }
    res.azResult = azNew;

References TabResult::azResult, sqlite3::errCode, TabResult::nAlloc, TabResult::nColumn, TabResult::nData, TabResult::nRow, TabResult::rc, sqlite3_exec, sqlite3_free, sqlite3_free_table, sqlite3_get_table_cb(), sqlite3_malloc64, sqlite3_mprintf, sqlite3Realloc(), sqlite3SafetyCheckOk(), SQLITE_ABORT, SQLITE_API, SQLITE_INT_TO_PTR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, and TabResult::zErrMsg.

Here is the call graph for this function:

◆ sqlite3_global_recover()

int sqlite3_global_recover ( void )

References SQLITE_API, and SQLITE_OK.

◆ sqlite3_hard_heap_limit64()

sqlite3_int64 sqlite3_hard_heap_limit64 ( sqlite3_int64 N )

                                                                   {
  sqlite3_int64 priorLimit;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.hardLimit;
  if( n>=0 ){
    mem0.hardLimit = n;
    if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){
      mem0.alarmThreshold = n;

References mem0, sqlite3_initialize(), sqlite3_mutex_enter, sqlite3_mutex_leave, and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_initialize()

int sqlite3_initialize ( void )

                                       {
  MUTEX_LOGIC( sqlite3_mutex *pMainMtx; )      /* The main static mutex */
  int rc;                                      /* Result code */
#ifdef SQLITE_EXTRA_INIT
  int bRunExtraInit = 0;                       /* Extra initialization needed */
#endif
 
#ifdef SQLITE_OMIT_WSD
  rc = sqlite3_wsd_init(4096, 24);
  if( rc!=SQLITE_OK ){
    return rc;
  }
#endif
 
  /* If the following assert() fails on some obscure processor/compiler
  ** combination, the work-around is to set the correct pointer
  ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
  assert( SQLITE_PTRSIZE==sizeof(char*) );
 
  /* If SQLite is already completely initialized, then this call
  ** to sqlite3_initialize() should be a no-op.  But the initialization
  ** must be complete.  So isInit must not be set until the very end
  ** of this routine.
  */
  if( sqlite3GlobalConfig.isInit ){
    sqlite3MemoryBarrier();
    return SQLITE_OK;
  }
 
  /* Make sure the mutex subsystem is initialized.  If unable to
  ** initialize the mutex subsystem, return early with the error.
  ** If the system is so sick that we are unable to allocate a mutex,
  ** there is not much SQLite is going to be able to do.
  **
  ** The mutex subsystem must take care of serializing its own
  ** initialization.
  */
  rc = sqlite3MutexInit();
  if( rc ) return rc;
 
  /* Initialize the malloc() system and the recursive pInitMutex mutex.
  ** This operation is protected by the STATIC_MAIN mutex.  Note that
  ** MutexAlloc() is called for a static mutex prior to initializing the
  ** malloc subsystem - this implies that the allocation of a static
  ** mutex must not require support from the malloc subsystem.
  */
  MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(pMainMtx);
  sqlite3GlobalConfig.isMutexInit = 1;
  if( !sqlite3GlobalConfig.isMallocInit ){
    rc = sqlite3MallocInit();
  }
  if( rc==SQLITE_OK ){
    sqlite3GlobalConfig.isMallocInit = 1;
    if( !sqlite3GlobalConfig.pInitMutex ){
      sqlite3GlobalConfig.pInitMutex =
           sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
      if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
        rc = SQLITE_NOMEM_BKPT;
      }
    }
  }
  if( rc==SQLITE_OK ){
    sqlite3GlobalConfig.nRefInitMutex++;
  }
  sqlite3_mutex_leave(pMainMtx);
 
  /* If rc is not SQLITE_OK at this point, then either the malloc
  ** subsystem could not be initialized or the system failed to allocate
  ** the pInitMutex mutex. Return an error in either case.  */
  if( rc!=SQLITE_OK ){
    return rc;
  }
 
  /* Do the rest of the initialization under the recursive mutex so
  ** that we will be able to handle recursive calls into
  ** sqlite3_initialize().  The recursive calls normally come through
  ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
  ** recursive calls might also be possible.
  **
  ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
  ** to the xInit method, so the xInit method need not be threadsafe.
  **
  ** The following mutex is what serializes access to the appdef pcache xInit
  ** methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
  ** call to sqlite3PcacheInitialize().
  */
  sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
  if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
    sqlite3GlobalConfig.inProgress = 1;
#ifdef SQLITE_ENABLE_SQLLOG
    {
      extern void sqlite3_init_sqllog(void);
      sqlite3_init_sqllog();
    }
#endif
    memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions));
    sqlite3RegisterBuiltinFunctions();
    if( sqlite3GlobalConfig.isPCacheInit==0 ){
      rc = sqlite3PcacheInitialize();
    }
    if( rc==SQLITE_OK ){
      sqlite3GlobalConfig.isPCacheInit = 1;
      rc = sqlite3OsInit();
    }
#ifndef SQLITE_OMIT_DESERIALIZE
    if( rc==SQLITE_OK ){
      rc = sqlite3MemdbInit();
    }
#endif
    if( rc==SQLITE_OK ){
      sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
          sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
#ifdef SQLITE_EXTRA_INIT_MUTEXED
      {
        int SQLITE_EXTRA_INIT_MUTEXED(const char*);
        rc = SQLITE_EXTRA_INIT_MUTEXED(0);
      }
#endif
    }
    if( rc==SQLITE_OK ){
      sqlite3MemoryBarrier();
      sqlite3GlobalConfig.isInit = 1;
#ifdef SQLITE_EXTRA_INIT
      bRunExtraInit = 1;
#endif
    }
    sqlite3GlobalConfig.inProgress = 0;
  }
  sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
 
  /* Go back under the static mutex and clean up the recursive
  ** mutex to prevent a resource leak.
  */
  sqlite3_mutex_enter(pMainMtx);
  sqlite3GlobalConfig.nRefInitMutex--;
  if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
    assert( sqlite3GlobalConfig.nRefInitMutex==0 );
    sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
    sqlite3GlobalConfig.pInitMutex = 0;
  }
  sqlite3_mutex_leave(pMainMtx);
 
  /* The following is just a sanity check to make sure SQLite has
  ** been compiled correctly.  It is important to run this code, but
  ** we don't want to run it too often and soak up CPU cycles for no
  ** reason.  So we run it once during initialization.
  */
#ifndef NDEBUG
#ifndef SQLITE_OMIT_FLOATING_POINT
  /* This section of code's only "output" is via assert() statements. */
  if( rc==SQLITE_OK ){
    u64 x = (((u64)1)<<63)-1;
    double y;
    assert(sizeof(x)==8);
    assert(sizeof(x)==sizeof(y));
    memcpy(&y, &x, 8);
    assert( sqlite3IsNaN(y) );
  }
#endif
#endif
 
  /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
  ** compile-time option.
  */
#ifdef SQLITE_EXTRA_INIT

References MUTEX_LOGIC, sqlite3_mutex_enter, sqlite3_mutex_free, sqlite3_mutex_leave, sqlite3BuiltinFunctions, sqlite3GlobalConfig, sqlite3IsNaN(), sqlite3MallocInit(), sqlite3MemdbInit(), sqlite3MemoryBarrier(), sqlite3MutexAlloc(), sqlite3MutexInit(), sqlite3OsInit(), sqlite3PCacheBufferSetup(), sqlite3PcacheInitialize(), sqlite3RegisterBuiltinFunctions(), SQLITE_API, SQLITE_MUTEX_RECURSIVE, SQLITE_MUTEX_STATIC_MAIN, SQLITE_NOMEM_BKPT, SQLITE_OK, and SQLITE_PTRSIZE.

Referenced by main(), openDatabase(), sqlite3_auto_extension(), sqlite3_complete16(), sqlite3_hard_heap_limit64(), sqlite3_soft_heap_limit64(), sqlite3_vfs_find(), and sqlite3_vfs_register().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite3_interrupt()

void sqlite3_interrupt ( sqlite3 * db )

                                              {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db)
   && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE)

References SQLITE_OK.

◆ sqlite3_is_interrupted()

int sqlite3_is_interrupted ( sqlite3 * db )

                                                  {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db)
   && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE)

◆ sqlite3_keyword_check()

int sqlite3_keyword_check	(	const char *	zName,
		int	nName )

References aKWLen, aKWOffset, SQLITE_ERROR, SQLITE_N_KEYWORD, SQLITE_OK, and zKWText.

◆ sqlite3_keyword_count()

int sqlite3_keyword_count ( void )

181444{

References SQLITE_API.

◆ sqlite3_keyword_name()

int sqlite3_keyword_name	(	int	i,
		const char **	pzName,
		int *	pnName )

                                                                    {
  int id = TK_ID;
  if( n>=2 ) keywordCode((char*)z, n, &id);
  return id;
}
#define SQLITE_N_KEYWORD 147

◆ sqlite3_last_insert_rowid()

sqlite3_int64 sqlite3_last_insert_rowid ( sqlite3 * db )

183705 {

183706#ifdef SQLITE_ENABLE_API_ARMOR

◆ sqlite3_libversion()

const char * sqlite3_libversion ( void )

References sqlite3_version, SQLITE_API, and SQLITE_VERSION.

◆ sqlite3_libversion_number()

int sqlite3_libversion_number ( void )

◆ sqlite3_limit()

int sqlite3_limit	(	sqlite3 *	db,
		int	id,
		int	newVal )

                                                                    {
  int oldLimit;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return -1;
  }
#endif
 
  /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
  ** there is a hard upper bound set at compile-time by a C preprocessor
  ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
  ** "_MAX_".)
  */
  assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
  assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
  assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
  assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
  assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
  assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
  assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
                                               SQLITE_MAX_LIKE_PATTERN_LENGTH );
  assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
  assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
  assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
  assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
 
 
  if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
    return -1;
  }
  oldLimit = db->aLimit[limitId];
  if( newLimit>=0 ){                   /* IMP: R-52476-28732 */
    if( newLimit>aHardLimit[limitId] ){
      newLimit = aHardLimit[limitId];  /* IMP: R-51463-25634 */

References aHardLimit, sqlite3::aLimit, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_LIMIT_ATTACHED, SQLITE_LIMIT_COLUMN, SQLITE_LIMIT_COMPOUND_SELECT, SQLITE_LIMIT_EXPR_DEPTH, SQLITE_LIMIT_FUNCTION_ARG, SQLITE_LIMIT_LENGTH, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, SQLITE_LIMIT_SQL_LENGTH, SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_LIMIT_VARIABLE_NUMBER, SQLITE_LIMIT_VDBE_OP, SQLITE_LIMIT_WORKER_THREADS, SQLITE_MAX_ATTACHED, SQLITE_MAX_COLUMN, SQLITE_MAX_COMPOUND_SELECT, SQLITE_MAX_EXPR_DEPTH, SQLITE_MAX_FUNCTION_ARG, SQLITE_MAX_LENGTH, SQLITE_MAX_LIKE_PATTERN_LENGTH, SQLITE_MAX_SQL_LENGTH, SQLITE_MAX_TRIGGER_DEPTH, SQLITE_MAX_VARIABLE_NUMBER, SQLITE_MAX_VDBE_OP, SQLITE_MAX_WORKER_THREADS, SQLITE_MIN_LENGTH, SQLITE_MISUSE_BKPT, and SQLITE_N_LIMIT.

Here is the call graph for this function:

◆ sqlite3_load_extension()

int sqlite3_load_extension	(	sqlite3 *	db,
		const char *	zFile,
		const char *	zProc,
		char **	pzErrMsg )

139764 {

139765 int rc;

References SQLITE_MAX_PATHLEN.

◆ sqlite3_log()

void sqlite3_log	(	int	iErrCode,
		const char *	zFormat,
			... )

33034 {

33035 va_list ap; /* Vararg list */

References sqlite3StrAccumFinish().

Here is the call graph for this function:

◆ sqlite3_malloc()

void * sqlite3_malloc ( int n )

31065 {

References SQLITE_API.

◆ sqlite3_malloc64()

void * sqlite3_malloc64 ( sqlite3_uint64 n )

                  : sqlite3Malloc(n);
}
SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){

◆ sqlite3_memory_alarm()

int sqlite3_memory_alarm	(	void(*	xCallback )(void *, sqlite3_int64, int),
		void *	pArg,
		sqlite3_int64	iThreshold )

30804 {

References SQLITE_API, and SQLITE_OK.

◆ sqlite3_memory_highwater()

sqlite3_int64 sqlite3_memory_highwater ( int resetFlag )

References sqlite3_status64, SQLITE_API, and SQLITE_STATUS_MEMORY_USED.

◆ sqlite3_memory_used()

sqlite3_int64 sqlite3_memory_used ( void )

◆ sqlite3_mprintf()

char * sqlite3_mprintf	(	const char *	zFormat,
			... )

                                                          {
  va_list ap;
  char *z;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;

◆ sqlite3_msize()

sqlite3_uint64 sqlite3_msize ( void * p )

◆ sqlite3_mutex_alloc()

sqlite3_mutex * sqlite3_mutex_alloc ( int id )

                                                     {
#ifndef SQLITE_OMIT_AUTOINIT
  if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;

◆ sqlite3_mutex_enter()

void sqlite3_mutex_enter ( sqlite3_mutex * p )

29553 {

References sqlite3GlobalConfig, and SQLITE_API.

◆ sqlite3_mutex_free()

void sqlite3_mutex_free ( sqlite3_mutex * p )

29542 {

◆ sqlite3_mutex_held()

int sqlite3_mutex_held ( sqlite3_mutex * )

References SQLITE_API.

◆ sqlite3_mutex_leave()

void sqlite3_mutex_leave ( sqlite3_mutex * p )

29579 {

References sqlite3GlobalConfig, and SQLITE_API.

◆ sqlite3_mutex_notheld()

int sqlite3_mutex_notheld ( sqlite3_mutex * )

References SQLITE_API.

◆ sqlite3_mutex_try()

int sqlite3_mutex_try ( sqlite3_mutex * p )

                                                  {
  int rc = SQLITE_OK;
  if( p ){

References sqlite3GlobalConfig, SQLITE_API, and SQLITE_OK.

◆ sqlite3_next_stmt()

sqlite3_stmt * sqlite3_next_stmt	(	sqlite3 *	pDb,
		sqlite3_stmt *	pStmt )

                                                                             {
  sqlite3_stmt *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(pDb) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(pDb->mutex);
  if( pStmt==0 ){
    pNext = (sqlite3_stmt*)pDb->pVdbe;

References sqlite3::mutex, sqlite3::pVdbe, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3SafetyCheckOk(), SQLITE_API, and SQLITE_MISUSE_BKPT.

Here is the call graph for this function:

◆ sqlite3_open()

int sqlite3_open	(	const char *	filename,
		sqlite3 **	ppDb )

◆ sqlite3_open16()

int sqlite3_open16	(	const void *	filename,
		sqlite3 **	ppDb )

 {
  char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */
  sqlite3_value *pVal;
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppDb = 0;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  if( zFilename==0 ) zFilename = "\000\000";
  pVal = sqlite3ValueNew(0);
  sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
  zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
  if( zFilename8 ){
    rc = openDatabase(zFilename8, ppDb,
                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
    assert( *ppDb || rc==SQLITE_NOMEM );
    if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
      SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
    }

◆ sqlite3_open_v2()

int sqlite3_open_v2	(	const char *	filename,
		sqlite3 **	ppDb,
		int	flags,
		const char *	zVfs )

 {
  return openDatabase(zFilename, ppDb,
                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
}
SQLITE_API int sqlite3_open_v2(

References openDatabase(), SQLITE_API, SQLITE_OPEN_CREATE, and SQLITE_OPEN_READWRITE.

Here is the call graph for this function:

◆ sqlite3_os_end()

int sqlite3_os_end ( void )

References SQLITE_API, SQLITE_OK, and unixBigLock.

Referenced by sqlite3_shutdown().

Here is the caller graph for this function:

◆ sqlite3_os_init()

int sqlite3_os_init ( void )

                                    {
  /*
  ** The following macro defines an initializer for an sqlite3_vfs object.
  ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
  ** to the "finder" function.  (pAppData is a pointer to a pointer because
  ** silly C90 rules prohibit a void* from being cast to a function pointer
  ** and so we have to go through the intermediate pointer to avoid problems
  ** when compiling with -pedantic-errors on GCC.)
  **
  ** The FINDER parameter to this macro is the name of the pointer to the
  ** finder-function.  The finder-function returns a pointer to the
  ** sqlite_io_methods object that implements the desired locking
  ** behaviors.  See the division above that contains the IOMETHODS
  ** macro for addition information on finder-functions.
  **
  ** Most finders simply return a pointer to a fixed sqlite3_io_methods
  ** object.  But the "autolockIoFinder" available on MacOSX does a little
  ** more than that; it looks at the filesystem type that hosts the
  ** database file and tries to choose an locking method appropriate for
  ** that filesystem time.
  */
  #define UNIXVFS(VFSNAME, FINDER) {                        \
    3,                    /* iVersion */                    \
    sizeof(unixFile),     /* szOsFile */                    \
    MAX_PATHNAME,         /* mxPathname */                  \
    0,                    /* pNext */                       \
    VFSNAME,              /* zName */                       \
    (void*)&FINDER,       /* pAppData */                    \
    unixOpen,             /* xOpen */                       \
    unixDelete,           /* xDelete */                     \
    unixAccess,           /* xAccess */                     \
    unixFullPathname,     /* xFullPathname */               \
    unixDlOpen,           /* xDlOpen */                     \
    unixDlError,          /* xDlError */                    \
    unixDlSym,            /* xDlSym */                      \
    unixDlClose,          /* xDlClose */                    \
    unixRandomness,       /* xRandomness */                 \
    unixSleep,            /* xSleep */                      \
    unixCurrentTime,      /* xCurrentTime */                \
    unixGetLastError,     /* xGetLastError */               \
    unixCurrentTimeInt64, /* xCurrentTimeInt64 */           \
    unixSetSystemCall,    /* xSetSystemCall */              \
    unixGetSystemCall,    /* xGetSystemCall */              \
    unixNextSystemCall,   /* xNextSystemCall */             \
  }
 
  /*
  ** All default VFSes for unix are contained in the following array.
  **
  ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
  ** by the SQLite core when the VFS is registered.  So the following
  ** array cannot be const.
  */
  static sqlite3_vfs aVfs[] = {
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    UNIXVFS("unix",          autolockIoFinder ),
#elif OS_VXWORKS
    UNIXVFS("unix",          vxworksIoFinder ),
#else
    UNIXVFS("unix",          posixIoFinder ),
#endif
    UNIXVFS("unix-none",     nolockIoFinder ),
    UNIXVFS("unix-dotfile",  dotlockIoFinder ),
    UNIXVFS("unix-excl",     posixIoFinder ),
#if OS_VXWORKS
    UNIXVFS("unix-namedsem", semIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS
    UNIXVFS("unix-posix",    posixIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
    UNIXVFS("unix-flock",    flockIoFinder ),
#endif
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    UNIXVFS("unix-afp",      afpIoFinder ),
    UNIXVFS("unix-nfs",      nfsIoFinder ),
    UNIXVFS("unix-proxy",    proxyIoFinder ),
#endif
  };
  unsigned int i;          /* Loop counter */
 
  /* Double-check that the aSyscall[] array has been constructed
  ** correctly.  See ticket [bb3a86e890c8e96ab] */
  assert( ArraySize(aSyscall)==29 );
 
  /* Register all VFSes defined in the aVfs[] array */
  for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
#ifdef SQLITE_DEFAULT_UNIX_VFS
    sqlite3_vfs_register(&aVfs[i],
           0==strcmp(aVfs[i].zName,SQLITE_DEFAULT_UNIX_VFS));
#else
    sqlite3_vfs_register(&aVfs[i], i==0);
#endif
  }
#ifdef SQLITE_OS_KV_OPTIONAL
  sqlite3KvvfsInit();
#endif
  unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
 
#ifndef SQLITE_OMIT_WAL
  /* Validate lock assumptions */
  assert( SQLITE_SHM_NLOCK==8 );  /* Number of available locks */
  assert( UNIX_SHM_BASE==120  );  /* Start of locking area */
  /* Locks:
  **    WRITE       UNIX_SHM_BASE      120
  **    CKPT        UNIX_SHM_BASE+1    121
  **    RECOVER     UNIX_SHM_BASE+2    122
  **    READ-0      UNIX_SHM_BASE+3    123
  **    READ-1      UNIX_SHM_BASE+4    124
  **    READ-2      UNIX_SHM_BASE+5    125
  **    READ-3      UNIX_SHM_BASE+6    126
  **    READ-4      UNIX_SHM_BASE+7    127
  **    DMS         UNIX_SHM_BASE+8    128
  */
  assert( UNIX_SHM_DMS==128   );  /* Byte offset of the deadman-switch */
#endif

References ArraySize, aSyscall, dotlockIoFinder, nolockIoFinder, posixIoFinder, sqlite3_vfs_register, sqlite3MutexAlloc(), SQLITE_API, SQLITE_MUTEX_STATIC_VFS1, SQLITE_OK, SQLITE_SHM_NLOCK, UNIX_SHM_BASE, UNIX_SHM_DMS, unixBigLock, unixTempFileInit(), and UNIXVFS.

Referenced by sqlite3OsInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite3_overload_function()

int sqlite3_overload_function	(	sqlite3 *	db,
		const char *	zFuncName,
		int	nArg )

 {
  int rc;
  char *zCopy;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;

References sqlite3::mutex, sqlite3_create_function_v2, sqlite3_free, sqlite3_mprintf, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3FindFunction(), sqlite3InvalidFunction(), sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_OK, and SQLITE_UTF8.

Here is the call graph for this function:

◆ sqlite3_prepare()

int sqlite3_prepare	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

References SQLITE_API.

◆ sqlite3_prepare16()

int sqlite3_prepare16	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

References SQLITE_API.

◆ sqlite3_prepare16_v2()

int sqlite3_prepare16_v2	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

 {
  int rc;
  rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare16_v2(
  sqlite3 *db,              /* Database handle. */
  const void *zSql,         /* UTF-16 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const void **pzTail       /* OUT: End of parsed string */

References sqlite3Prepare16(), and SQLITE_OK.

Here is the call graph for this function:

◆ sqlite3_prepare16_v3()

int sqlite3_prepare16_v3	(	sqlite3 *	db,
		const void *	zSql,
		int	nByte,
		unsigned int	prepFlags,
		sqlite3_stmt **	ppStmt,
		const void **	pzTail )

 {
  int rc;
  rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare16_v3(
  sqlite3 *db,              /* Database handle. */
  const void *zSql,         /* UTF-16 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  unsigned int prepFlags,   /* Zero or more SQLITE_PREPARE_* flags */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const void **pzTail       /* OUT: End of parsed string */
){
  int rc;

References sqlite3Prepare16(), SQLITE_OK, and SQLITE_PREPARE_SAVESQL.

Here is the call graph for this function:

◆ sqlite3_prepare_v2()

int sqlite3_prepare_v2	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

 {
  int rc;
  rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
}
SQLITE_API int sqlite3_prepare_v2(
  sqlite3 *db,              /* Database handle. */
  const char *zSql,         /* UTF-8 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const char **pzTail       /* OUT: End of parsed string */
){
  int rc;
  /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
  ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags
  ** parameter.
  **

References sqlite3LockAndPrepare(), and SQLITE_OK.

Here is the call graph for this function:

◆ sqlite3_prepare_v3()

int sqlite3_prepare_v3	(	sqlite3 *	db,
		const char *	zSql,
		int	nByte,
		unsigned int	prepFlags,
		sqlite3_stmt **	ppStmt,
		const char **	pzTail )

 {
  int rc;
  /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
  ** sqlite3_prepare_v2() only in having the extra prepFlags parameter,
  ** which is a bit array consisting of zero or more of the
  ** SQLITE_PREPARE_* flags.
  **
  ** Proof by comparison to the implementation of sqlite3_prepare_v2()
  ** directly above. */

References SQLITE_OK, and SQLITE_PREPARE_SAVESQL.

◆ sqlite3_profile()

void * sqlite3_profile	(	sqlite3 *	db,
		void(*	xProfile )(void , const char , sqlite3_uint64),
		void *	pArg )

 {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;

References sqlite3::mTrace, sqlite3::mutex, sqlite3::pProfileArg, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_TRACE_NONLEGACY_MASK, SQLITE_TRACE_XPROFILE, and sqlite3::xProfile.

Here is the call graph for this function:

◆ sqlite3_progress_handler()

void sqlite3_progress_handler	(	sqlite3 *	db,
		int	nOps,
		int(*	xProgress )(void *),
		void *	pArg )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( nOps>0 ){
    db->xProgress = xProgress;
    db->nProgressOps = (unsigned)nOps;
    db->pProgressArg = pArg;

References sqlite3::mutex, sqlite3::nProgressOps, sqlite3::pProgressArg, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, and sqlite3::xProgress.

Here is the call graph for this function:

◆ sqlite3_randomness()

void sqlite3_randomness	(	int	N,
		void *	P )

                                                     {
  unsigned char *zBuf = pBuf;
 
  /* The "wsdPrng" macro will resolve to the pseudo-random number generator
  ** state vector.  If writable static data is unsupported on the target,
  ** we have to locate the state vector at run-time.  In the more common
  ** case where writable static data is supported, wsdPrng can refer directly
  ** to the "sqlite3Prng" state vector declared above.
  */
#ifdef SQLITE_OMIT_WSD
  struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
# define wsdPrng p[0]
#else
# define wsdPrng sqlite3Prng
#endif
 
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
 
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return;
#endif
 
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
#endif
 
  sqlite3_mutex_enter(mutex);
  if( N<=0 || pBuf==0 ){
    wsdPrng.s[0] = 0;
    sqlite3_mutex_leave(mutex);
    return;
  }
 
  /* Initialize the state of the random number generator once,
  ** the first time this routine is called.
  */
  if( wsdPrng.s[0]==0 ){
    sqlite3_vfs *pVfs = sqlite3_vfs_find(0);
    static const u32 chacha20_init[] = {
      0x61707865, 0x3320646e, 0x79622d32, 0x6b206574
    };
    memcpy(&wsdPrng.s[0], chacha20_init, 16);
    if( NEVER(pVfs==0) ){
      memset(&wsdPrng.s[4], 0, 44);
    }else{
      sqlite3OsRandomness(pVfs, 44, (char*)&wsdPrng.s[4]);
    }
    wsdPrng.s[15] = wsdPrng.s[12];
    wsdPrng.s[12] = 0;
    wsdPrng.n = 0;
  }
 
  assert( N>0 );
  while( 1 /* exit by break */ ){
    if( N<=wsdPrng.n ){
      memcpy(zBuf, &wsdPrng.out[wsdPrng.n-N], N);
      wsdPrng.n -= N;
      break;
    }
    if( wsdPrng.n>0 ){
      memcpy(zBuf, wsdPrng.out, wsdPrng.n);
      N -= wsdPrng.n;
      zBuf += wsdPrng.n;
    }

◆ sqlite3_realloc()

void * sqlite3_realloc	(	void *	pOld,
		int	n )

31312 {

31313#ifndef SQLITE_OMIT_AUTOINIT

References SQLITE_API.

◆ sqlite3_realloc64()

void * sqlite3_realloc64	(	void *	pOld,
		sqlite3_uint64	n )

31319 {

◆ sqlite3_release_memory()

int sqlite3_release_memory ( int n )

                                            {
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
  return sqlite3PcacheReleaseMemory(n);
#else
  /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
  ** is a no-op returning zero if SQLite is not compiled with

References SQLITE_API, and UNUSED_PARAMETER.

◆ sqlite3_reset()

int sqlite3_reset ( sqlite3_stmt * pStmt )

                                                 {
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeRewind(v);

References checkProfileCallback, Vdbe::db, sqlite3::errMask, sqlite3::mutex, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3ApiExit(), sqlite3VdbeReset(), sqlite3VdbeRewind(), SQLITE_API, and SQLITE_OK.

Here is the call graph for this function:

◆ sqlite3_reset_auto_extension()

void sqlite3_reset_auto_extension ( void )

                                                  {
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize()==SQLITE_OK )
#endif
  {
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);

Referenced by sqlite3_shutdown().

Here is the caller graph for this function:

◆ sqlite3_result_blob()

void sqlite3_result_blob	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void(*	xDel )(void *) )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 || n<0 ){
    invokeValueDestructor(z, xDel, pCtx);
    return;

References SQLITE_TOOBIG.

◆ sqlite3_result_blob64()

void sqlite3_result_blob64	(	sqlite3_context *	pCtx,
		const void *	z,
		sqlite3_uint64	n,
		void(*	xDel )(void *) )

 {
  assert( xDel!=SQLITE_DYNAMIC );
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ){
    invokeValueDestructor(z, xDel, 0);
    return;
  }
#endif
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

◆ sqlite3_result_double()

void sqlite3_result_double	(	sqlite3_context *	pCtx,
		double	rVal )

                    {
    (void)invokeValueDestructor(z, xDel, pCtx);
  }else{
    setResultStrOrError(pCtx, z, (int)n, 0, xDel);
  }
}
SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){

References invokeValueDestructor().

Here is the call graph for this function:

◆ sqlite3_result_error()

void sqlite3_result_error	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n )

91937 {

91938#ifdef SQLITE_ENABLE_API_ARMOR

◆ sqlite3_result_error16()

void sqlite3_result_error16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n )

91946 {

91947#ifdef SQLITE_ENABLE_API_ARMOR

References SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF8.

◆ sqlite3_result_error_code()

void sqlite3_result_error_code	(	sqlite3_context *	pCtx,
		int	errCode )

                                                                             {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;
#endif
  pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
  if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;

References SQLITE_OK.

◆ sqlite3_result_error_nomem()

void sqlite3_result_error_nomem ( sqlite3_context * pCtx )

                                                                 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;

References SQLITE_STATIC, SQLITE_TOOBIG, and SQLITE_UTF8.

◆ sqlite3_result_error_toobig()

void sqlite3_result_error_toobig ( sqlite3_context * pCtx )

                                                                  {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;

References SQLITE_STATIC, and SQLITE_UTF8.

◆ sqlite3_result_int()

void sqlite3_result_int	(	sqlite3_context *	pCtx,
		int	iVal )

91955 {

References SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF16NATIVE.

◆ sqlite3_result_int64()

void sqlite3_result_int64	(	sqlite3_context *	pCtx,
		sqlite3_int64	iVal )

91962 {

◆ sqlite3_result_null()

void sqlite3_result_null ( sqlite3_context * pCtx )

91969 {

◆ sqlite3_result_pointer()

void sqlite3_result_pointer	(	sqlite3_context *	pCtx,
		void *	pPtr,
		const char *	zPType,
		void(*	xDestructor )(void *) )

 {
  Mem *pOut;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ){
    invokeValueDestructor(pPtr, xDestructor, 0);
    return;
  }
#endif

◆ sqlite3_result_subtype()

void sqlite3_result_subtype	(	sqlite3_context *	pCtx,
		unsigned int	eSubtype )

                                                                                    {
  Mem *pOut;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;
#endif
#if defined(SQLITE_STRICT_SUBTYPE) && SQLITE_STRICT_SUBTYPE+0!=0
  if( pCtx->pFunc!=0
   && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
  ){
    char zErr[200];
    sqlite3_snprintf(sizeof(zErr), zErr,
                     "misuse of sqlite3_result_subtype() by %s()",
                     pCtx->pFunc->zName);
    sqlite3_result_error(pCtx, zErr, -1);
    return;
  }

References MEM_Null.

◆ sqlite3_result_text()

void sqlite3_result_text	(	sqlite3_context *	pCtx,
		const char *	z,
		int	n,
		void(*	xDel )(void *) )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ){
    invokeValueDestructor(z, xDel, 0);

References MEM_Subtype.

◆ sqlite3_result_text16()

void sqlite3_result_text16	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void(*	xDel )(void *) )

       {
    setResultStrOrError(pCtx, z, (int)n, enc, xDel);
    sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
  }
}
#ifndef SQLITE_OMIT_UTF16
SQLITE_API void sqlite3_result_text16(
  sqlite3_context *pCtx,
  const void *z,

◆ sqlite3_result_text16be()

void sqlite3_result_text16be	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void(*	xDel )(void *) )

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16NATIVE, xDel);
}
SQLITE_API void sqlite3_result_text16be(
  sqlite3_context *pCtx,
  const void *z,

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16NATIVE.

Here is the call graph for this function:

◆ sqlite3_result_text16le()

void sqlite3_result_text16le	(	sqlite3_context *	pCtx,
		const void *	z,
		int	n,
		void(*	xDel )(void *) )

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16BE, xDel);
}
SQLITE_API void sqlite3_result_text16le(
  sqlite3_context *pCtx,
  const void *z,

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16BE.

Here is the call graph for this function:

◆ sqlite3_result_text64()

void sqlite3_result_text64	(	sqlite3_context *	pCtx,
		const char *	z,
		sqlite3_uint64	n,
		void(*	xDel )(void *),
		unsigned char	encoding )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ){
    invokeValueDestructor(z, xDel, 0);
    return;
  }
#endif
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );
  if( enc!=SQLITE_UTF8 ){
    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
    n &= ~(u64)1;
  }
  if( n>0x7fffffff ){

◆ sqlite3_result_value()

void sqlite3_result_value	(	sqlite3_context *	pCtx,
		sqlite3_value *	pValue )

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16LE, xDel);
}
#endif /* SQLITE_OMIT_UTF16 */
SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
  Mem *pOut;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;
  if( pValue==0 ){
    sqlite3_result_null(pCtx);
    return;
  }
#endif
  pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

References sqlite3_value::db, sqlite3::mutex, sqlite3_context::pOut, setResultStrOrError(), sqlite3_mutex_held(), and SQLITE_UTF16LE.

Here is the call graph for this function:

◆ sqlite3_result_zeroblob()

void sqlite3_result_zeroblob	(	sqlite3_context *	pCtx,
		int	n )

92101 {

◆ sqlite3_result_zeroblob64()

int sqlite3_result_zeroblob64	(	sqlite3_context *	pCtx,
		sqlite3_uint64	n )

                                                                     {
  sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0);
}
SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
  Mem *pOut;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );
  if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
    sqlite3_result_error_toobig(pCtx);
    return SQLITE_TOOBIG;
  }
#ifndef SQLITE_OMIT_INCRBLOB

◆ sqlite3_rollback_hook()

void * sqlite3_rollback_hook	(	sqlite3 *	db,
		void(*	xCallback )(void *),
		void *	pArg )

 {
  void *pRet;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif

◆ sqlite3_rtree_geometry_callback()

int sqlite3_rtree_geometry_callback	(	sqlite3 *	db,
		const char *	zGeom,
		int(*	xGeom )(sqlite3_rtree_geometry , int, sqlite3_rtree_dbl , int *),
		void *	pContext )

References SQLITE_API.

◆ sqlite3_rtree_query_callback()

int sqlite3_rtree_query_callback	(	sqlite3 *	db,
		const char *	zQueryFunc,
		int(*	xQueryFunc )(sqlite3_rtree_query_info *),
		void *	pContext,
		void(*	xDestructor )(void *) )

References SQLITE_API.

◆ sqlite3_serialize()

unsigned char * sqlite3_serialize	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_int64 *	piSize,
		unsigned int	mFlags )

 {
  MemFile *p;
  int iDb;
  Btree *pBt;
  sqlite3_int64 sz;
  int szPage = 0;
  sqlite3_stmt *pStmt = 0;
  unsigned char *pOut;
  char *zSql;
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
 
  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
  p = memdbFromDbSchema(db, zSchema);
  iDb = sqlite3FindDbName(db, zSchema);
  if( piSize ) *piSize = -1;
  if( iDb<0 ) return 0;
  if( p ){
    MemStore *pStore = p->pStore;
    assert( pStore->pMutex==0 );
    if( piSize ) *piSize = pStore->sz;
    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
      pOut = pStore->aData;
    }else{
      pOut = sqlite3_malloc64( pStore->sz );
      if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
    }
    return pOut;
  }
  pBt = db->aDb[iDb].pBt;
  if( pBt==0 ) return 0;
  szPage = sqlite3BtreeGetPageSize(pBt);
  zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema);
  rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
  sqlite3_free(zSql);
  if( rc ) return 0;
  rc = sqlite3_step(pStmt);
  if( rc!=SQLITE_ROW ){
    pOut = 0;
  }else{
    sz = sqlite3_column_int64(pStmt, 0)*szPage;
    if( sz==0 ){
      sqlite3_reset(pStmt);
      sqlite3_exec(db, "BEGIN IMMEDIATE; COMMIT;", 0, 0, 0);
      rc = sqlite3_step(pStmt);
      if( rc==SQLITE_ROW ){
        sz = sqlite3_column_int64(pStmt, 0)*szPage;
      }
    }
    if( piSize ) *piSize = sz;
    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
      pOut = 0;
    }else{
      pOut = sqlite3_malloc64( sz );
      if( pOut ){
        int nPage = sqlite3_column_int(pStmt, 0);
        Pager *pPager = sqlite3BtreePager(pBt);
        int pgno;
        for(pgno=1; pgno<=nPage; pgno++){
          DbPage *pPage = 0;
          unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
          rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
          if( rc==SQLITE_OK ){
            memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
          }else{
            memset(pTo, 0, szPage);
          }
          sqlite3PagerUnref(pPage);
        }

◆ sqlite3_set_authorizer()

int sqlite3_set_authorizer	(	sqlite3 *	db,
		int(*	xAuth )(void , int, const char , const char , const char , const char *),
		void *	pUserData )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mutex, sqlite3::pAuthArg, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3ExpirePreparedStatements(), sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_OK, and sqlite3::xAuth.

Here is the call graph for this function:

◆ sqlite3_set_auxdata()

void sqlite3_set_auxdata	(	sqlite3_context *	pCtx,
		int	N,
		void *	pAux,
		void(*	xDelete )(void *) )

                        :  If iArg is negative then make the data available
** to all functions within the current prepared statement using iArg as an
** access code.
*/
SQLITE_API void sqlite3_set_auxdata(
  sqlite3_context *pCtx,
  int iArg,
  void *pAux,
  void (*xDelete)(void*)
){
  AuxData *pAuxData;
  Vdbe *pVdbe;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCtx==0 ) return;
#endif
  pVdbe= pCtx->pVdbe;
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#ifdef SQLITE_ENABLE_STAT4
  if( pVdbe==0 ) goto failed;
#else
  assert( pVdbe!=0 );
#endif
 
  for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
    if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
      break;
    }
  }
  if( pAuxData==0 ){
    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
    if( !pAuxData ) goto failed;
    pAuxData->iAuxOp = pCtx->iOp;
    pAuxData->iAuxArg = iArg;
    pAuxData->pNextAux = pVdbe->pAuxData;
    pVdbe->pAuxData = pAuxData;
    if( pCtx->isError==0 ) pCtx->isError = -1;
  }else if( pAuxData->xDeleteAux ){
    pAuxData->xDeleteAux(pAuxData->pAux);
  }
 
  pAuxData->pAux = pAux;
  pAuxData->xDeleteAux = xDelete;
  return;

References sqlite3_value::db, Vdbe::db, AuxData::iAuxArg, AuxData::iAuxOp, sqlite3_context::iOp, sqlite3_context::isError, sqlite3::mutex, AuxData::pAux, Vdbe::pAuxData, AuxData::pNextAux, sqlite3_context::pOut, sqlite3_context::pVdbe, sqlite3_mutex_held(), sqlite3DbMallocZero(), SQLITE_API, and AuxData::xDeleteAux.

Here is the call graph for this function:

◆ sqlite3_set_clientdata()

int sqlite3_set_clientdata	(	sqlite3 *	db,
		const char *	zName,
		void *	pData,
		void(*	xDestructor )(void *) )

 {
  DbClientData *p, **pp;
  sqlite3_mutex_enter(db->mutex);
  pp = &db->pDbData;
  for(p=db->pDbData; p && strcmp(p->zName,zName); p=p->pNext){
    pp = &p->pNext;
  }
  if( p ){
    assert( p->pData!=0 );
    if( p->xDestructor ) p->xDestructor(p->pData);
    if( pData==0 ){
      *pp = p->pNext;
      sqlite3_free(p);
      sqlite3_mutex_leave(db->mutex);
      return SQLITE_OK;
    }
  }else if( pData==0 ){
    sqlite3_mutex_leave(db->mutex);
    return SQLITE_OK;
  }else{
    size_t n = strlen(zName);
    p = sqlite3_malloc64( SZ_DBCLIENTDATA(n+1) );
    if( p==0 ){
      if( xDestructor ) xDestructor(pData);
      sqlite3_mutex_leave(db->mutex);
      return SQLITE_NOMEM;
    }
    memcpy(p->zName, zName, n+1);
    p->pNext = db->pDbData;

◆ sqlite3_set_last_insert_rowid()

void sqlite3_set_last_insert_rowid	(	sqlite3 *	db,
		sqlite3_int64	iRowid )

                                                                                {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;

◆ sqlite3_setlk_timeout()

int sqlite3_setlk_timeout	(	sqlite3 *	db,
		int	ms,
		int	flags )

                                                                    {
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  int iDb;
  int bBOC = ((flags & SQLITE_SETLK_BLOCK_ON_CONNECT) ? 1 : 0);
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( ms<-1 ) return SQLITE_RANGE;
#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
  sqlite3_mutex_enter(db->mutex);
  db->setlkTimeout = ms;
  db->setlkFlags = flags;
  sqlite3BtreeEnterAll(db);
  for(iDb=0; iDb<db->nDb; iDb++){
    Btree *pBt = db->aDb[iDb].pBt;
    if( pBt ){
      sqlite3_file *fd = sqlite3PagerFile(sqlite3BtreePager(pBt));
      sqlite3OsFileControlHint(fd, SQLITE_FCNTL_BLOCK_ON_CONNECT, (void*)&bBOC);
    }
  }
  sqlite3BtreeLeaveAll(db);
  sqlite3_mutex_leave(db->mutex);

◆ sqlite3_shutdown()

int sqlite3_shutdown ( void )

                                     {
#ifdef SQLITE_OMIT_WSD
  int rc = sqlite3_wsd_init(4096, 24);
  if( rc!=SQLITE_OK ){
    return rc;
  }
#endif
 
  if( sqlite3GlobalConfig.isInit ){
#ifdef SQLITE_EXTRA_SHUTDOWN
    void SQLITE_EXTRA_SHUTDOWN(void);
    SQLITE_EXTRA_SHUTDOWN();
#endif
    sqlite3_os_end();
    sqlite3_reset_auto_extension();
    sqlite3GlobalConfig.isInit = 0;
  }
  if( sqlite3GlobalConfig.isPCacheInit ){
    sqlite3PcacheShutdown();
    sqlite3GlobalConfig.isPCacheInit = 0;
  }
  if( sqlite3GlobalConfig.isMallocInit ){
    sqlite3MallocEnd();
    sqlite3GlobalConfig.isMallocInit = 0;
 
#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
    /* The heap subsystem has now been shutdown and these values are supposed
    ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
    ** which would rely on that heap subsystem; therefore, make sure these
    ** values cannot refer to heap memory that was just invalidated when the
    ** heap subsystem was shutdown.  This is only done if the current call to
    ** this function resulted in the heap subsystem actually being shutdown.
    */
    sqlite3_data_directory = 0;
    sqlite3_temp_directory = 0;
#endif
  }

References sqlite3_data_directory, sqlite3_os_end(), sqlite3_reset_auto_extension(), sqlite3_temp_directory, sqlite3GlobalConfig, sqlite3MallocEnd(), sqlite3MutexEnd(), sqlite3PcacheShutdown(), SQLITE_API, and SQLITE_OK.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite3_sleep()

int sqlite3_sleep ( int ms )

                                    {
  sqlite3_vfs *pVfs;
  int rc;
  pVfs = sqlite3_vfs_find(0);
  if( pVfs==0 ) return 0;

◆ sqlite3_snapshot_cmp()

int sqlite3_snapshot_cmp	(	sqlite3_snapshot *	p1,
		sqlite3_snapshot *	p2 )

References SQLITE_API, and SQLITE_EXPERIMENTAL.

◆ sqlite3_snapshot_free()

void sqlite3_snapshot_free ( sqlite3_snapshot * )

References SQLITE_API, and SQLITE_EXPERIMENTAL.

◆ sqlite3_snapshot_get()

int sqlite3_snapshot_get	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_snapshot **	ppSnapshot )

References SQLITE_API, and SQLITE_EXPERIMENTAL.

◆ sqlite3_snapshot_open()

int sqlite3_snapshot_open	(	sqlite3 *	db,
		const char *	zSchema,
		sqlite3_snapshot *	pSnapshot )

References SQLITE_API, and SQLITE_EXPERIMENTAL.

◆ sqlite3_snapshot_recover()

int sqlite3_snapshot_recover	(	sqlite3 *	db,
		const char *	zDb )

References SQLITE_API, and SQLITE_EXPERIMENTAL.

◆ sqlite3_snprintf()

char * sqlite3_snprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
			... )

                                                                              {
  StrAccum acc;
  va_list ap;
  if( n<=0 ) return zBuf;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zBuf==0 || zFormat==0 ) {
    (void)SQLITE_MISUSE_BKPT;
    if( zBuf ) zBuf[0] = 0;
    return zBuf;
  }
#endif
  sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);

◆ sqlite3_soft_heap_limit()

void sqlite3_soft_heap_limit ( int N )

References mem0.

◆ sqlite3_soft_heap_limit64()

sqlite3_int64 sqlite3_soft_heap_limit64 ( sqlite3_int64 N )

                                                                   {
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
  sqlite3_int64 nUsed;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  if( n<0 ){
    sqlite3_mutex_leave(mem0.mutex);
    return priorLimit;
  }
  if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){
    n = mem0.hardLimit;
  }
  mem0.alarmThreshold = n;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed);

References AtomicStore, mem0, sqlite3_initialize(), sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3StatusValue(), SQLITE_API, and SQLITE_STATUS_MEMORY_USED.

Here is the call graph for this function:

◆ sqlite3_sourceid()

const char * sqlite3_sourceid ( void )

Referenced by sourceidFunc().

Here is the caller graph for this function:

◆ sqlite3_sql()

const char * sqlite3_sql ( sqlite3_stmt * pStmt )

◆ sqlite3_status()

int sqlite3_status	(	int	op,
		int *	pCurrent,
		int *	pHighwater,
		int	resetFlag )

                                                                                    {
  sqlite3_int64 iCur = 0, iHwtr = 0;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){

◆ sqlite3_status64()

int sqlite3_status64	(	int	op,
		sqlite3_int64 *	pCurrent,
		sqlite3_int64 *	pHighwater,
		int	resetFlag )

 {
  sqlite3_mutex *pMutex;
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
  sqlite3_mutex_enter(pMutex);
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];

◆ sqlite3_step()

int sqlite3_step ( sqlite3_stmt * pStmt )

                                                {
  int rc = SQLITE_OK;      /* Result from sqlite3Step() */
  Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
  sqlite3 *db;             /* The database connection */
 
  if( vdbeSafetyNotNull(v) ){
    return SQLITE_MISUSE_BKPT;
  }
  db = v->db;
  sqlite3_mutex_enter(db->mutex);
  while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
         && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
    int savedPc = v->pc;
    rc = sqlite3Reprepare(v);
    if( rc!=SQLITE_OK ){
      /* This case occurs after failing to recompile an sql statement.
      ** The error message from the SQL compiler has already been loaded
      ** into the database handle. This block copies the error message
      ** from the database handle into the statement and sets the statement
      ** program counter to 0 to ensure that when the statement is
      ** finalized or reset the parser error message is available via
      ** sqlite3_errmsg() and sqlite3_errcode().
      */
      const char *zErr = (const char *)sqlite3_value_text(db->pErr);
      sqlite3DbFree(db, v->zErrMsg);
      if( !db->mallocFailed ){
        v->zErrMsg = sqlite3DbStrDup(db, zErr);
        v->rc = rc = sqlite3ApiExit(db, rc);
      } else {
        v->zErrMsg = 0;
        v->rc = rc = SQLITE_NOMEM_BKPT;
      }
      break;
    }
    sqlite3_reset(pStmt);
    if( savedPc>=0 ){
      /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and
      ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because it has
      ** already been done once on a prior invocation that failed due to
      ** SQLITE_SCHEMA.   tag-20220401a  */
      v->minWriteFileFormat = 254;

References Vdbe::db, Vdbe::expired, sqlite3::mallocFailed, Vdbe::minWriteFileFormat, sqlite3::mutex, Vdbe::pc, sqlite3::pErr, Vdbe::rc, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3_reset, sqlite3_value_text, sqlite3ApiExit(), sqlite3DbFree(), sqlite3DbStrDup(), sqlite3Reprepare(), sqlite3Step(), SQLITE_API, SQLITE_MAX_SCHEMA_RETRY, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_SCHEMA, vdbeSafetyNotNull(), and Vdbe::zErrMsg.

Here is the call graph for this function:

◆ sqlite3_stmt_busy()

int sqlite3_stmt_busy ( sqlite3_stmt * pStmt )

◆ sqlite3_stmt_explain()

int sqlite3_stmt_explain	(	sqlite3_stmt *	pStmt,
		int	eMode )

                                         : 0;
}
 
/*
** Set the explain mode for a statement.
*/
SQLITE_API int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode){
  Vdbe *v = (Vdbe*)pStmt;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pStmt==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(v->db->mutex);
  if( ((int)v->explain)==eMode ){
    rc = SQLITE_OK;
  }else if( eMode<0 || eMode>2 ){
    rc = SQLITE_ERROR;
  }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
    rc = SQLITE_ERROR;
  }else if( v->eVdbeState!=VDBE_READY_STATE ){
    rc = SQLITE_BUSY;
  }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
    /* No reprepare necessary */
    v->explain = eMode;
    rc = SQLITE_OK;
  }else{
    v->explain = eMode;
    rc = sqlite3Reprepare(v);
    v->haveEqpOps = eMode==2;
  }
  if( v->explain ){
    v->nResColumn = 12 - 4*v->explain;

◆ sqlite3_stmt_isexplain()

int sqlite3_stmt_isexplain ( sqlite3_stmt * pStmt )

◆ sqlite3_stmt_readonly()

int sqlite3_stmt_readonly ( sqlite3_stmt * pStmt )

◆ sqlite3_stmt_scanstatus()

int sqlite3_stmt_scanstatus	(	sqlite3_stmt *	pStmt,
		int	idx,
		int	iScanStatusOp,
		void *	pOut )

References SQLITE_API.

◆ sqlite3_stmt_scanstatus_reset()

void sqlite3_stmt_scanstatus_reset ( sqlite3_stmt * )

References SQLITE_API.

◆ sqlite3_stmt_scanstatus_v2()

int sqlite3_stmt_scanstatus_v2	(	sqlite3_stmt *	pStmt,
		int	idx,
		int	iScanStatusOp,
		int	flags,
		void *	pOut )

References SQLITE_API.

◆ sqlite3_stmt_status()

int sqlite3_stmt_status	(	sqlite3_stmt *	pStmt,
		int	op,
		int	resetFlg )

                                                                              {
  Vdbe *pVdbe = (Vdbe*)pStmt;
  u32 v;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !pStmt
   || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
  ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  if( op==SQLITE_STMTSTATUS_MEMUSED ){
    sqlite3 *db = pVdbe->db;
    sqlite3_mutex_enter(db->mutex);
    v = 0;
    db->pnBytesFreed = (int*)&v;
    assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );
    db->lookaside.pEnd = db->lookaside.pStart;
    sqlite3VdbeDelete(pVdbe);
    db->pnBytesFreed = 0;
    db->lookaside.pEnd = db->lookaside.pTrueEnd;
    sqlite3_mutex_leave(db->mutex);

◆ sqlite3_str_append()

void sqlite3_str_append	(	sqlite3_str *	p,
		const char *	zIn,
		int	N )

                                                                        {
  assert( z!=0 || N==0 );
  assert( p->zText!=0 || p->nChar==0 || p->accError );
  assert( N>=0 );
  assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
  if( p->nChar+N >= p->nAlloc ){
    enlargeAndAppend(p,z,N);

◆ sqlite3_str_appendall()

void sqlite3_str_appendall	(	sqlite3_str *	p,
		const char *	zIn )

◆ sqlite3_str_appendchar()

void sqlite3_str_appendchar	(	sqlite3_str *	p,
		int	N,
		char	C )

32695 {

◆ sqlite3_str_appendf()

void sqlite3_str_appendf	(	sqlite3_str *	p,
		const char *	zFormat,
			... )

References sqlite3_str_vappendf, and SQLITE_API.

◆ sqlite3_str_errcode()

int sqlite3_str_errcode ( sqlite3_str * p )

◆ sqlite3_str_finish()

char * sqlite3_str_finish ( sqlite3_str * p )

                                   {
   0, 0, 0, 0, 0, SQLITE_NOMEM, 0
};
 
/* Finalize a string created using sqlite3_str_new().
*/
SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){
  char *z;
  if( p!=0 && p!=&sqlite3OomStr ){
    z = sqlite3StrAccumFinish(p);

References sqlite3OomStr, and SQLITE_NOMEM.

◆ sqlite3_str_length()

int sqlite3_str_length ( sqlite3_str * p )

32813 {

32814 return p ? p->accError : SQLITE_NOMEM;

References sqlite3_str::accError, SQLITE_API, and SQLITE_NOMEM.

◆ sqlite3_str_new()

sqlite3_str * sqlite3_str_new ( sqlite3 * db )

                                                    {
  sqlite3_str *p = sqlite3_malloc64(sizeof(*p));
  if( p ){
    sqlite3StrAccumInit(p, 0, 0, 0,

◆ sqlite3_str_reset()

void sqlite3_str_reset ( sqlite3_str * p )

                                              {
  if( isMalloced(p) ){
    sqlite3DbFree(p->db, p->zText);

◆ sqlite3_str_value()

char * sqlite3_str_value ( sqlite3_str * p )

                                                 {
  return p ? p->nChar : 0;
}
 

References sqlite3_str::nChar, and SQLITE_API.

◆ sqlite3_str_vappendf()

void sqlite3_str_vappendf	(	sqlite3_str *	pAccum,
		const char *	zFormat,
		va_list	ap )

 {
  int c;                     /* Next character in the format string */
  char *bufpt;               /* Pointer to the conversion buffer */
  int precision;             /* Precision of the current field */
  int length;                /* Length of the field */
  int idx;                   /* A general purpose loop counter */
  int width;                 /* Width of the current field */
  etByte flag_leftjustify;   /* True if "-" flag is present */
  etByte flag_prefix;        /* '+' or ' ' or 0 for prefix */
  etByte flag_alternateform; /* True if "#" flag is present */
  etByte flag_altform2;      /* True if "!" flag is present */
  etByte flag_zeropad;       /* True if field width constant starts with zero */
  etByte flag_long;          /* 1 for the "l" flag, 2 for "ll", 0 by default */
  etByte done;               /* Loop termination flag */
  etByte cThousand;          /* Thousands separator for %d and %u */
  etByte xtype = etINVALID;  /* Conversion paradigm */
  u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */
  char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
  sqlite_uint64 longvalue;   /* Value for integer types */
  double realvalue;          /* Value for real types */
  const et_info *infop;      /* Pointer to the appropriate info structure */
  char *zOut;                /* Rendering buffer */
  int nOut;                  /* Size of the rendering buffer */
  char *zExtra = 0;          /* Malloced memory used by some conversion */
  int exp, e2;               /* exponent of real numbers */
  etByte flag_dp;            /* True if decimal point should be shown */
  etByte flag_rtz;           /* True if trailing zeros should be removed */
 
  PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
  char buf[etBUFSIZE];       /* Conversion buffer */
 
  /* pAccum never starts out with an empty buffer that was obtained from
  ** malloc().  This precondition is required by the mprintf("%z...")
  ** optimization. */
  assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
 
  bufpt = 0;
  if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){
    pArgList = va_arg(ap, PrintfArguments*);
    bArgList = 1;
  }else{
    bArgList = 0;
  }
  for(; (c=(*fmt))!=0; ++fmt){
    if( c!='%' ){
      bufpt = (char *)fmt;
#if HAVE_STRCHRNUL
      fmt = strchrnul(fmt, '%');
#else
      do{ fmt++; }while( *fmt && *fmt != '%' );
#endif
      sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt));
      if( *fmt==0 ) break;
    }
    if( (c=(*++fmt))==0 ){
      sqlite3_str_append(pAccum, "%", 1);
      break;
    }
    /* Find out what flags are present */
    flag_leftjustify = flag_prefix = cThousand =
     flag_alternateform = flag_altform2 = flag_zeropad = 0;
    done = 0;
    width = 0;
    flag_long = 0;
    precision = -1;
    do{
      switch( c ){
        case '-':   flag_leftjustify = 1;     break;
        case '+':   flag_prefix = '+';        break;
        case ' ':   flag_prefix = ' ';        break;
        case '#':   flag_alternateform = 1;   break;
        case '!':   flag_altform2 = 1;        break;
        case '0':   flag_zeropad = 1;         break;
        case ',':   cThousand = ',';          break;
        default:    done = 1;                 break;
        case 'l': {
          flag_long = 1;
          c = *++fmt;
          if( c=='l' ){
            c = *++fmt;
            flag_long = 2;
          }
          done = 1;
          break;
        }
        case '1': case '2': case '3': case '4': case '5':
        case '6': case '7': case '8': case '9': {
          unsigned wx = c - '0';
          while( (c = *++fmt)>='0' && c<='9' ){
            wx = wx*10 + c - '0';
          }
          testcase( wx>0x7fffffff );
          width = wx & 0x7fffffff;
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
            width = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( c!='.' && c!='l' ){
            done = 1;
          }else{
            fmt--;
          }
          break;
        }
        case '*': {
          if( bArgList ){
            width = (int)getIntArg(pArgList);
          }else{
            width = va_arg(ap,int);
          }
          if( width<0 ){
            flag_leftjustify = 1;
            width = width >= -2147483647 ? -width : 0;
          }
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
            width = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( (c = fmt[1])!='.' && c!='l' ){
            c = *++fmt;
            done = 1;
          }
          break;
        }
        case '.': {
          c = *++fmt;
          if( c=='*' ){
            if( bArgList ){
              precision = (int)getIntArg(pArgList);
            }else{
              precision = va_arg(ap,int);
            }
            if( precision<0 ){
              precision = precision >= -2147483647 ? -precision : -1;
            }
            c = *++fmt;
          }else{
            unsigned px = 0;
            while( c>='0' && c<='9' ){
              px = px*10 + c - '0';
              c = *++fmt;
            }
            testcase( px>0x7fffffff );
            precision = px & 0x7fffffff;
          }
#ifdef SQLITE_PRINTF_PRECISION_LIMIT
          if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
            precision = SQLITE_PRINTF_PRECISION_LIMIT;
          }
#endif
          if( c=='l' ){
            --fmt;
          }else{
            done = 1;
          }
          break;
        }
      }
    }while( !done && (c=(*++fmt))!=0 );
 
    /* Fetch the info entry for the field */
    infop = &fmtinfo[0];
    xtype = etINVALID;
    for(idx=0; idx<ArraySize(fmtinfo); idx++){
      if( c==fmtinfo[idx].fmttype ){
        infop = &fmtinfo[idx];
        xtype = infop->type;
        break;
      }
    }
 
    /*
    ** At this point, variables are initialized as follows:
    **
    **   flag_alternateform          TRUE if a '#' is present.
    **   flag_altform2               TRUE if a '!' is present.
    **   flag_prefix                 '+' or ' ' or zero
    **   flag_leftjustify            TRUE if a '-' is present or if the
    **                               field width was negative.
    **   flag_zeropad                TRUE if the width began with 0.
    **   flag_long                   1 for "l", 2 for "ll"
    **   width                       The specified field width.  This is
    **                               always non-negative.  Zero is the default.
    **   precision                   The specified precision.  The default
    **                               is -1.
    **   xtype                       The class of the conversion.
    **   infop                       Pointer to the appropriate info struct.
    */
    assert( width>=0 );
    assert( precision>=(-1) );
    switch( xtype ){
      case etPOINTER:
        flag_long = sizeof(char*)==sizeof(i64) ? 2 :
                     sizeof(char*)==sizeof(long int) ? 1 : 0;
        /* no break */ deliberate_fall_through
      case etORDINAL:
      case etRADIX:
        cThousand = 0;
        /* no break */ deliberate_fall_through
      case etDECIMAL:
        if( infop->flags & FLAG_SIGNED ){
          i64 v;
          if( bArgList ){
            v = getIntArg(pArgList);
          }else if( flag_long ){
            if( flag_long==2 ){
              v = va_arg(ap,i64) ;
            }else{
              v = va_arg(ap,long int);
            }
          }else{
            v = va_arg(ap,int);
          }
          if( v<0 ){
            testcase( v==SMALLEST_INT64 );
            testcase( v==(-1) );
            longvalue = ~v;
            longvalue++;
            prefix = '-';
          }else{
            longvalue = v;
            prefix = flag_prefix;
          }
        }else{
          if( bArgList ){
            longvalue = (u64)getIntArg(pArgList);
          }else if( flag_long ){
            if( flag_long==2 ){
              longvalue = va_arg(ap,u64);
            }else{
              longvalue = va_arg(ap,unsigned long int);
            }
          }else{
            longvalue = va_arg(ap,unsigned int);
          }
          prefix = 0;
        }
        if( longvalue==0 ) flag_alternateform = 0;
        if( flag_zeropad && precision<width-(prefix!=0) ){
          precision = width-(prefix!=0);
        }
        if( precision<etBUFSIZE-10-etBUFSIZE/3 ){
          nOut = etBUFSIZE;
          zOut = buf;
        }else{
          u64 n;
          n = (u64)precision + 10;
          if( cThousand ) n += precision/3;
          zOut = zExtra = printfTempBuf(pAccum, n);
          if( zOut==0 ) return;
          nOut = (int)n;
        }
        bufpt = &zOut[nOut-1];
        if( xtype==etORDINAL ){
          static const char zOrd[] = "thstndrd";
          int x = (int)(longvalue % 10);
          if( x>=4 || (longvalue/10)%10==1 ){
            x = 0;
          }
          *(--bufpt) = zOrd[x*2+1];
          *(--bufpt) = zOrd[x*2];
        }
        {
          const char *cset = &aDigits[infop->charset];
          u8 base = infop->base;
          do{                                           /* Convert to ascii */
            *(--bufpt) = cset[longvalue%base];
            longvalue = longvalue/base;
          }while( longvalue>0 );
        }
        length = (int)(&zOut[nOut-1]-bufpt);
        while( precision>length ){
          *(--bufpt) = '0';                             /* Zero pad */
          length++;
        }
        if( cThousand ){
          int nn = (length - 1)/3;  /* Number of "," to insert */
          int ix = (length - 1)%3 + 1;
          bufpt -= nn;
          for(idx=0; nn>0; idx++){
            bufpt[idx] = bufpt[idx+nn];
            ix--;
            if( ix==0 ){
              bufpt[++idx] = cThousand;
              nn--;
              ix = 3;
            }
          }
        }
        if( prefix ) *(--bufpt) = prefix;               /* Add sign */
        if( flag_alternateform && infop->prefix ){      /* Add "0" or "0x" */
          const char *pre;
          char x;
          pre = &aPrefix[infop->prefix];
          for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
        }
        length = (int)(&zOut[nOut-1]-bufpt);
        break;
      case etFLOAT:
      case etEXP:
      case etGENERIC: {
        FpDecode s;
        int iRound;
        int j;
 
        if( bArgList ){
          realvalue = getDoubleArg(pArgList);
        }else{
          realvalue = va_arg(ap,double);
        }
        if( precision<0 ) precision = 6;         /* Set default precision */
#ifdef SQLITE_FP_PRECISION_LIMIT
        if( precision>SQLITE_FP_PRECISION_LIMIT ){
          precision = SQLITE_FP_PRECISION_LIMIT;
        }
#endif
        if( xtype==etFLOAT ){
          iRound = -precision;
        }else if( xtype==etGENERIC ){
          if( precision==0 ) precision = 1;
          iRound = precision;
        }else{
          iRound = precision+1;
        }
        sqlite3FpDecode(&s, realvalue, iRound, flag_altform2 ? 26 : 16);
        if( s.isSpecial ){
          if( s.isSpecial==2 ){
            bufpt = flag_zeropad ? "null" : "NaN";
            length = sqlite3Strlen30(bufpt);
            break;
          }else if( flag_zeropad ){
            s.z[0] = '9';
            s.iDP = 1000;
            s.n = 1;
          }else{
            memcpy(buf, "-Inf", 5);
            bufpt = buf;
            if( s.sign=='-' ){
              /* no-op */
            }else if( flag_prefix ){
              buf[0] = flag_prefix;
            }else{
              bufpt++;
            }
            length = sqlite3Strlen30(bufpt);
            break;
          }
        }
        if( s.sign=='-' ){
          prefix = '-';
        }else{
          prefix = flag_prefix;
        }
 
        exp = s.iDP-1;
 
        /*
        ** If the field type is etGENERIC, then convert to either etEXP
        ** or etFLOAT, as appropriate.
        */
        if( xtype==etGENERIC ){
          assert( precision>0 );
          precision--;
          flag_rtz = !flag_alternateform;
          if( exp<-4 || exp>precision ){
            xtype = etEXP;
          }else{
            precision = precision - exp;
            xtype = etFLOAT;
          }
        }else{
          flag_rtz = flag_altform2;
        }
        if( xtype==etEXP ){
          e2 = 0;
        }else{
          e2 = s.iDP - 1;
        }
        bufpt = buf;
        {
          i64 szBufNeeded;           /* Size of a temporary buffer needed */
          szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15;
          if( cThousand && e2>0 ) szBufNeeded += (e2+2)/3;
          if( szBufNeeded > etBUFSIZE ){
            bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded);
            if( bufpt==0 ) return;
          }
        }
        zOut = bufpt;
        flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
        /* The sign in front of the number */
        if( prefix ){
          *(bufpt++) = prefix;
        }
        /* Digits prior to the decimal point */
        j = 0;
        if( e2<0 ){
          *(bufpt++) = '0';
        }else{
          for(; e2>=0; e2--){
            *(bufpt++) = j<s.n ? s.z[j++] : '0';
            if( cThousand && (e2%3)==0 && e2>1 ) *(bufpt++) = ',';
          }
        }
        /* The decimal point */
        if( flag_dp ){
          *(bufpt++) = '.';
        }
        /* "0" digits after the decimal point but before the first
        ** significant digit of the number */
        for(e2++; e2<0 && precision>0; precision--, e2++){
          *(bufpt++) = '0';
        }
        /* Significant digits after the decimal point */
        while( (precision--)>0 ){
          *(bufpt++) = j<s.n ? s.z[j++] : '0';
        }
        /* Remove trailing zeros and the "." if no digits follow the "." */
        if( flag_rtz && flag_dp ){
          while( bufpt[-1]=='0' ) *(--bufpt) = 0;
          assert( bufpt>zOut );
          if( bufpt[-1]=='.' ){
            if( flag_altform2 ){
              *(bufpt++) = '0';
            }else{
              *(--bufpt) = 0;
            }
          }
        }
        /* Add the "eNNN" suffix */
        if( xtype==etEXP ){
          exp = s.iDP - 1;
          *(bufpt++) = aDigits[infop->charset];
          if( exp<0 ){
            *(bufpt++) = '-'; exp = -exp;
          }else{
            *(bufpt++) = '+';
          }
          if( exp>=100 ){
            *(bufpt++) = (char)((exp/100)+'0');        /* 100's digit */
            exp %= 100;
          }
          *(bufpt++) = (char)(exp/10+'0');             /* 10's digit */
          *(bufpt++) = (char)(exp%10+'0');             /* 1's digit */
        }
        *bufpt = 0;
 
        /* The converted number is in buf[] and zero terminated. Output it.
        ** Note that the number is in the usual order, not reversed as with
        ** integer conversions. */
        length = (int)(bufpt-zOut);
        bufpt = zOut;
 
        /* Special case:  Add leading zeros if the flag_zeropad flag is
        ** set and we are not left justified */
        if( flag_zeropad && !flag_leftjustify && length < width){
          int i;
          int nPad = width - length;
          for(i=width; i>=nPad; i--){
            bufpt[i] = bufpt[i-nPad];
          }
          i = prefix!=0;
          while( nPad-- ) bufpt[i++] = '0';
          length = width;
        }
        break;
      }
      case etSIZE:
        if( !bArgList ){
          *(va_arg(ap,int*)) = pAccum->nChar;
        }
        length = width = 0;
        break;
      case etPERCENT:
        buf[0] = '%';
        bufpt = buf;
        length = 1;
        break;
      case etCHARX:
        if( bArgList ){
          bufpt = getTextArg(pArgList);
          length = 1;
          if( bufpt ){
            buf[0] = c = *(bufpt++);
            if( (c&0xc0)==0xc0 ){
              while( length<4 && (bufpt[0]&0xc0)==0x80 ){
                buf[length++] = *(bufpt++);
              }
            }
          }else{
            buf[0] = 0;
          }
        }else{
          unsigned int ch = va_arg(ap,unsigned int);
          length = sqlite3AppendOneUtf8Character(buf, ch);
        }
        if( precision>1 ){
          i64 nPrior = 1;
          width -= precision-1;
          if( width>1 && !flag_leftjustify ){
            sqlite3_str_appendchar(pAccum, width-1, ' ');
            width = 0;
          }
          sqlite3_str_append(pAccum, buf, length);
          precision--;
          while( precision > 1 ){
            i64 nCopyBytes;
            if( nPrior > precision-1 ) nPrior = precision - 1;
            nCopyBytes = length*nPrior;
            if( nCopyBytes + pAccum->nChar >= pAccum->nAlloc ){
              sqlite3StrAccumEnlarge(pAccum, nCopyBytes);
            }
            if( pAccum->accError ) break;
            sqlite3_str_append(pAccum,
                 &pAccum->zText[pAccum->nChar-nCopyBytes], nCopyBytes);
            precision -= nPrior;
            nPrior *= 2;
          }
        }
        bufpt = buf;
        flag_altform2 = 1;
        goto adjust_width_for_utf8;
      case etSTRING:
      case etDYNSTRING:
        if( bArgList ){
          bufpt = getTextArg(pArgList);
          xtype = etSTRING;
        }else{
          bufpt = va_arg(ap,char*);
        }
        if( bufpt==0 ){
          bufpt = "";
        }else if( xtype==etDYNSTRING ){
          if( pAccum->nChar==0
           && pAccum->mxAlloc
           && width==0
           && precision<0
           && pAccum->accError==0
          ){
            /* Special optimization for sqlite3_mprintf("%z..."):
            ** Extend an existing memory allocation rather than creating
            ** a new one. */
            assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
            pAccum->zText = bufpt;
            pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt);
            pAccum->nChar = 0x7fffffff & (int)strlen(bufpt);
            pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED;
            length = 0;
            break;
          }
          zExtra = bufpt;
        }
        if( precision>=0 ){
          if( flag_altform2 ){
            /* Set length to the number of bytes needed in order to display
            ** precision characters */
            unsigned char *z = (unsigned char*)bufpt;
            while( precision-- > 0 && z[0] ){
              SQLITE_SKIP_UTF8(z);
            }
            length = (int)(z - (unsigned char*)bufpt);
          }else{
            for(length=0; length<precision && bufpt[length]; length++){}
          }
        }else{
          length = 0x7fffffff & (int)strlen(bufpt);
        }
      adjust_width_for_utf8:
        if( flag_altform2 && width>0 ){
          /* Adjust width to account for extra bytes in UTF-8 characters */
          int ii = length - 1;
          while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++;
        }
        break;
      case etESCAPE_q:          /* %q: Escape ' characters */
      case etESCAPE_Q:          /* %Q: Escape ' and enclose in '...' */
      case etESCAPE_w: {        /* %w: Escape " characters */
        i64 i, j, k, n;
        int needQuote = 0;
        char ch;
        char *escarg;
        char q;
 
        if( bArgList ){
          escarg = getTextArg(pArgList);
        }else{
          escarg = va_arg(ap,char*);
        }
        if( escarg==0 ){
          escarg = (xtype==etESCAPE_Q ? "NULL" : "(NULL)");
        }else if( xtype==etESCAPE_Q ){
          needQuote = 1;
        }
        if( xtype==etESCAPE_w ){
          q = '"';
          flag_alternateform = 0;
        }else{
          q = '\'';
        }
        /* For %q, %Q, and %w, the precision is the number of bytes (or
        ** characters if the ! flags is present) to use from the input.
        ** Because of the extra quoting characters inserted, the number
        ** of output characters may be larger than the precision.
        */
        k = precision;
        for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
          if( ch==q )  n++;
          if( flag_altform2 && (ch&0xc0)==0xc0 ){
            while( (escarg[i+1]&0xc0)==0x80 ){ i++; }
          }
        }
        if( flag_alternateform ){
          /* For %#q, do unistr()-style backslash escapes for
          ** all control characters, and for backslash itself.
          ** For %#Q, do the same but only if there is at least
          ** one control character. */
          u32 nBack = 0;
          u32 nCtrl = 0;
          for(k=0; k<i; k++){
            if( escarg[k]=='\\' ){
              nBack++;
            }else if( ((u8*)escarg)[k]<=0x1f ){
              nCtrl++;
            }
          }
          if( nCtrl || xtype==etESCAPE_q ){
            n += nBack + 5*nCtrl;
            if( xtype==etESCAPE_Q ){
              n += 10;
              needQuote = 2;
            }
          }else{
            flag_alternateform = 0;
          }
        }
        n += i + 3;
        if( n>etBUFSIZE ){
          bufpt = zExtra = printfTempBuf(pAccum, n);
          if( bufpt==0 ) return;
        }else{
          bufpt = buf;
        }
        j = 0;
        if( needQuote ){
          if( needQuote==2 ){
            memcpy(&bufpt[j], "unistr('", 8);
            j += 8;
          }else{
            bufpt[j++] = '\'';
          }
        }
        k = i;
        if( flag_alternateform ){
          for(i=0; i<k; i++){
            bufpt[j++] = ch = escarg[i];
            if( ch==q ){
              bufpt[j++] = ch;
            }else if( ch=='\\' ){
              bufpt[j++] = '\\';
            }else if( ((unsigned char)ch)<=0x1f ){
              bufpt[j-1] = '\\';
              bufpt[j++] = 'u';
              bufpt[j++] = '0';
              bufpt[j++] = '0';
              bufpt[j++] = ch>=0x10 ? '1' : '0';
              bufpt[j++] = "0123456789abcdef"[ch&0xf];
            }
          }
        }else{
          for(i=0; i<k; i++){
            bufpt[j++] = ch = escarg[i];
            if( ch==q ) bufpt[j++] = ch;
          }
        }
        if( needQuote ){
          bufpt[j++] = '\'';
          if( needQuote==2 ) bufpt[j++] = ')';
        }
        bufpt[j] = 0;
        length = j;
        goto adjust_width_for_utf8;
      }
      case etTOKEN: {
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        if( flag_alternateform ){
          /* %#T means an Expr pointer that uses Expr.u.zToken */
          Expr *pExpr = va_arg(ap,Expr*);
          if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){
            sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken);
            sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr);
          }
        }else{
          /* %T means a Token pointer */
          Token *pToken = va_arg(ap, Token*);
          assert( bArgList==0 );
          if( pToken && pToken->n ){
            sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
            sqlite3RecordErrorByteOffset(pAccum->db, pToken->z);
          }
        }
        length = width = 0;
        break;
      }
      case etSRCITEM: {
        SrcItem *pItem;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        pItem = va_arg(ap, SrcItem*);
        assert( bArgList==0 );
        if( pItem->zAlias && !flag_altform2 ){
          sqlite3_str_appendall(pAccum, pItem->zAlias);
        }else if( pItem->zName ){
          if( pItem->fg.fixedSchema==0
           && pItem->fg.isSubquery==0
           && pItem->u4.zDatabase!=0
          ){
            sqlite3_str_appendall(pAccum, pItem->u4.zDatabase);
            sqlite3_str_append(pAccum, ".", 1);
          }
          sqlite3_str_appendall(pAccum, pItem->zName);
        }else if( pItem->zAlias ){
          sqlite3_str_appendall(pAccum, pItem->zAlias);
        }else if( ALWAYS(pItem->fg.isSubquery) ){/* Because of tag-20240424-1 */
          Select *pSel = pItem->u4.pSubq->pSelect;
          assert( pSel!=0 );
          if( pSel->selFlags & SF_NestedFrom ){
            sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId);
          }else if( pSel->selFlags & SF_MultiValue ){
            assert( !pItem->fg.isTabFunc && !pItem->fg.isIndexedBy );
            sqlite3_str_appendf(pAccum, "%u-ROW VALUES CLAUSE",
                                pItem->u1.nRow);
          }else{
            sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId);
          }
        }
        length = width = 0;
        break;
      }
      default: {
        assert( xtype==etINVALID );
        return;
      }
    }/* End switch over the format type */
    /*
    ** The text of the conversion is pointed to by "bufpt" and is
    ** "length" characters long.  The field width is "width".  Do
    ** the output.  Both length and width are in bytes, not characters,
    ** at this point.  If the "!" flag was present on string conversions
    ** indicating that width and precision should be expressed in characters,
    ** then the values have been translated prior to reaching this point.
    */
    width -= length;
    if( width>0 ){
      if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
      sqlite3_str_append(pAccum, bufpt, length);
      if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
    }else{
      sqlite3_str_append(pAccum, bufpt, length);
    }
 

References sqlite3_str::accError, aDigits, ALWAYS, aPrefix, ArraySize, et_info::base, c, et_info::charset, sqlite3_str::db, deliberate_fall_through, EP_IntValue, etBUFSIZE, etCHARX, etDECIMAL, etDYNSTRING, etESCAPE_Q, etESCAPE_q, etESCAPE_w, etEXP, etFLOAT, etGENERIC, etINVALID, etORDINAL, etPERCENT, etPOINTER, etRADIX, etSIZE, etSRCITEM, etSTRING, etTOKEN, ExprHasProperty, SrcItem::fg, FLAG_SIGNED, et_info::flags, fmtinfo, getDoubleArg(), getIntArg(), getTextArg(), FpDecode::iDP, FpDecode::isSpecial, MAX, sqlite3_str::mxAlloc, FpDecode::n, Token::n, sqlite3_str::nAlloc, sqlite3_str::nChar, et_info::prefix, sqlite3_str::printfFlags, printfTempBuf(), Select::selFlags, Select::selId, SF_MultiValue, SF_NestedFrom, FpDecode::sign, SMALLEST_INT64, sqlite3_str_append, sqlite3_str_appendall, sqlite3_str_appendchar, sqlite3_str_appendf, sqlite3AppendOneUtf8Character(), sqlite3DbFree(), sqlite3DbMallocSize(), sqlite3FpDecode(), sqlite3RecordErrorByteOffset(), sqlite3RecordErrorOffsetOfExpr(), sqlite3StrAccumEnlarge(), sqlite3Strlen30(), SQLITE_API, SQLITE_FP_PRECISION_LIMIT, SQLITE_PRINTF_INTERNAL, SQLITE_PRINTF_MALLOCED, SQLITE_PRINTF_SQLFUNC, SQLITE_SKIP_UTF8, testcase, et_info::type, Expr::u, SrcItem::u1, SrcItem::u4, FpDecode::z, Token::z, SrcItem::zAlias, SrcItem::zName, and sqlite3_str::zText.

Here is the call graph for this function:

◆ sqlite3_strglob()

int sqlite3_strglob	(	const char *	zGlob,
		const char *	zStr )

                                                                             {
  if( zString==0 ){
    return zGlobPattern!=0;

◆ sqlite3_stricmp()

int sqlite3_stricmp	(	const char *	zLeft,
		const char *	zRight )

                    : R-30243-02494 The sqlite3_stricmp() and
** sqlite3_strnicmp() APIs allow applications and extensions to compare
** the contents of two buffers containing UTF-8 strings in a
** case-independent fashion, using the same definition of "case
** independence" that SQLite uses internally when comparing identifiers.
*/
SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
  if( zLeft==0 ){

References SQLITE_API.

◆ sqlite3_strlike()

int sqlite3_strlike	(	const char *	zGlob,
		const char *	zStr,
		unsigned int	cEsc )

                                                                                        {
  if( zStr==0 ){
    return zPattern!=0;

◆ sqlite3_strnicmp()

int sqlite3_strnicmp	(	const char *	zLeft,
		const char *	zRight,
		int	N )

                                                                             {
  register unsigned char *a, *b;
  if( zLeft==0 ){
    return zRight ? -1 : 0;
  }else if( zRight==0 ){
    return 1;

◆ sqlite3_system_errno()

int sqlite3_system_errno ( sqlite3 * db )

185386 {

References SQLITE_MISUSE_BKPT.

◆ sqlite3_table_column_metadata()

int sqlite3_table_column_metadata	(	sqlite3 *	db,
		const char *	zDbName,
		const char *	zTableName,
		const char *	zColumnName,
		char const **	pzDataType,
		char const **	pzCollSeq,
		int *	pNotNull,
		int *	pPrimaryKey,
		int *	pAutoinc )

 {
  int rc;
  char *zErrMsg = 0;
  Table *pTab = 0;
  Column *pCol = 0;
  int iCol = 0;
  char const *zDataType = 0;
  char const *zCollSeq = 0;
  int notnull = 0;
  int primarykey = 0;
  int autoinc = 0;
 
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
 
  /* Ensure the database schema has been loaded */
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  rc = sqlite3Init(db, &zErrMsg);
  if( SQLITE_OK!=rc ){
    goto error_out;
  }
 
  /* Locate the table in question */
  pTab = sqlite3FindTable(db, zTableName, zDbName);
  if( !pTab || IsView(pTab) ){
    pTab = 0;
    goto error_out;
  }
 
  /* Find the column for which info is requested */
  if( zColumnName==0 ){
    /* Query for existence of table only */
  }else{
    iCol = sqlite3ColumnIndex(pTab, zColumnName);
    if( iCol>=0 ){
      pCol = &pTab->aCol[iCol];
    }else{
      if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
        iCol = pTab->iPKey;
        pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
      }else{
        pTab = 0;
        goto error_out;
      }
    }
  }
 
  /* The following block stores the meta information that will be returned
  ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
  ** and autoinc. At this point there are two possibilities:
  **
  **     1. The specified column name was rowid", "oid" or "_rowid_"
  **        and there is no explicitly declared IPK column.
  **
  **     2. The table is not a view and the column name identified an
  **        explicitly declared column. Copy meta information from *pCol.
  */
  if( pCol ){
    zDataType = sqlite3ColumnType(pCol,0);
    zCollSeq = sqlite3ColumnColl(pCol);
    notnull = pCol->notNull!=0;
    primarykey  = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
    autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
  }else{
    zDataType = "INTEGER";
    primarykey = 1;
  }
  if( !zCollSeq ){
    zCollSeq = sqlite3StrBINARY;
  }
 
error_out:
  sqlite3BtreeLeaveAll(db);
 
  /* Whether the function call succeeded or failed, set the output parameters
  ** to whatever their local counterparts contain. If an error did occur,
  ** this has the effect of zeroing all output parameters.
  */
  if( pzDataType ) *pzDataType = zDataType;
  if( pzCollSeq ) *pzCollSeq = zCollSeq;
  if( pNotNull ) *pNotNull = notnull;
  if( pPrimaryKey ) *pPrimaryKey = primarykey;
  if( pAutoinc ) *pAutoinc = autoinc;
 
  if( SQLITE_OK==rc && !pTab ){
    sqlite3DbFree(db, zErrMsg);
    zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
        zColumnName);
    rc = SQLITE_ERROR;

◆ sqlite3_test_control()

int sqlite3_test_control	(	int	op,
			... )

                                                {
  int rc = 0;
#ifdef SQLITE_UNTESTABLE
  UNUSED_PARAMETER(op);
#else
  va_list ap;
  va_start(ap, op);
  switch( op ){
 
    /*
    ** Save the current state of the PRNG.
    */
    case SQLITE_TESTCTRL_PRNG_SAVE: {
      sqlite3PrngSaveState();
      break;
    }
 
    /*
    ** Restore the state of the PRNG to the last state saved using
    ** PRNG_SAVE.  If PRNG_SAVE has never before been called, then
    ** this verb acts like PRNG_RESET.
    */
    case SQLITE_TESTCTRL_PRNG_RESTORE: {
      sqlite3PrngRestoreState();
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db);
    **
    ** Control the seed for the pseudo-random number generator (PRNG) that
    ** is built into SQLite.  Cases:
    **
    **    x!=0 && db!=0       Seed the PRNG to the current value of the
    **                        schema cookie in the main database for db, or
    **                        x if the schema cookie is zero.  This case
    **                        is convenient to use with database fuzzers
    **                        as it allows the fuzzer some control over the
    **                        the PRNG seed.
    **
    **    x!=0 && db==0       Seed the PRNG to the value of x.
    **
    **    x==0 && db==0       Revert to default behavior of using the
    **                        xRandomness method on the primary VFS.
    **
    ** This test-control also resets the PRNG so that the new seed will
    ** be used for the next call to sqlite3_randomness().
    */
#ifndef SQLITE_OMIT_WSD
    case SQLITE_TESTCTRL_PRNG_SEED: {
      int x = va_arg(ap, int);
      int y;
      sqlite3 *db = va_arg(ap, sqlite3*);
      assert( db==0 || db->aDb[0].pSchema!=0 );
      if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; }
      sqlite3Config.iPrngSeed = x;
      sqlite3_randomness(0,0);
      break;
    }
#endif
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_FK_NO_ACTION, sqlite3 *db, int b);
    **
    ** If b is true, then activate the SQLITE_FkNoAction setting.  If b is
    ** false then clear that setting.  If the SQLITE_FkNoAction setting is
    ** enabled, all foreign key ON DELETE and ON UPDATE actions behave as if
    ** they were NO ACTION, regardless of how they are defined.
    **
    ** NB:  One must usually run "PRAGMA writable_schema=RESET" after
    ** using this test-control, before it will take full effect.  failing
    ** to reset the schema can result in some unexpected behavior.
    */
    case SQLITE_TESTCTRL_FK_NO_ACTION: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      int b = va_arg(ap, int);
      if( b ){
        db->flags |= SQLITE_FkNoAction;
      }else{
        db->flags &= ~SQLITE_FkNoAction;
      }
      break;
    }
 
    /*
    **  sqlite3_test_control(BITVEC_TEST, size, program)
    **
    ** Run a test against a Bitvec object of size.  The program argument
    ** is an array of integers that defines the test.  Return -1 on a
    ** memory allocation error, 0 on success, or non-zero for an error.
    ** See the sqlite3BitvecBuiltinTest() for additional information.
    */
    case SQLITE_TESTCTRL_BITVEC_TEST: {
      int sz = va_arg(ap, int);
      int *aProg = va_arg(ap, int*);
      rc = sqlite3BitvecBuiltinTest(sz, aProg);
      break;
    }
 
    /*
    **  sqlite3_test_control(FAULT_INSTALL, xCallback)
    **
    ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
    ** if xCallback is not NULL.
    **
    ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
    ** is called immediately after installing the new callback and the return
    ** value from sqlite3FaultSim(0) becomes the return from
    ** sqlite3_test_control().
    */
    case SQLITE_TESTCTRL_FAULT_INSTALL: {
      /* A bug in MSVC prevents it from understanding pointers to functions
      ** types in the second argument to va_arg().  Work around the problem
      ** using a typedef.
      ** http://support.microsoft.com/kb/47961  <-- dead hyperlink
      ** Search at http://web.archive.org/ to find the 2015-03-16 archive
      ** of the link above to see the original text.
      ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
      */
      typedef int(*sqlite3FaultFuncType)(int);
      sqlite3GlobalConfig.xTestCallback = va_arg(ap, sqlite3FaultFuncType);
      rc = sqlite3FaultSim(0);
      break;
    }
 
    /*
    **  sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
    **
    ** Register hooks to call to indicate which malloc() failures
    ** are benign.
    */
    case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
      typedef void (*void_function)(void);
      void_function xBenignBegin;
      void_function xBenignEnd;
      xBenignBegin = va_arg(ap, void_function);
      xBenignEnd = va_arg(ap, void_function);
      sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
      break;
    }
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
    **
    ** Set the PENDING byte to the value in the argument, if X>0.
    ** Make no changes if X==0.  Return the value of the pending byte
    ** as it existing before this routine was called.
    **
    ** IMPORTANT:  Changing the PENDING byte from 0x40000000 results in
    ** an incompatible database file format.  Changing the PENDING byte
    ** while any database connection is open results in undefined and
    ** deleterious behavior.
    */
    case SQLITE_TESTCTRL_PENDING_BYTE: {
      rc = PENDING_BYTE;
#ifndef SQLITE_OMIT_WSD
      {
        unsigned int newVal = va_arg(ap, unsigned int);
        if( newVal ) sqlite3PendingByte = newVal;
      }
#endif
      break;
    }
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
    **
    ** This action provides a run-time test to see whether or not
    ** assert() was enabled at compile-time.  If X is true and assert()
    ** is enabled, then the return value is true.  If X is true and
    ** assert() is disabled, then the return value is zero.  If X is
    ** false and assert() is enabled, then the assertion fires and the
    ** process aborts.  If X is false and assert() is disabled, then the
    ** return value is zero.
    */
    case SQLITE_TESTCTRL_ASSERT: {
      volatile int x = 0;
      assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
      rc = x;
#if defined(SQLITE_DEBUG)
      /* Invoke these debugging routines so that the compiler does not
      ** issue "defined but not used" warnings. */
      if( x==9999 ){
        sqlite3ShowExpr(0);
        sqlite3ShowExprList(0);
        sqlite3ShowIdList(0);
        sqlite3ShowSrcList(0);
        sqlite3ShowWith(0);
        sqlite3ShowUpsert(0);
#ifndef SQLITE_OMIT_TRIGGER
        sqlite3ShowTriggerStep(0);
        sqlite3ShowTriggerStepList(0);
        sqlite3ShowTrigger(0);
        sqlite3ShowTriggerList(0);
#endif
#ifndef SQLITE_OMIT_WINDOWFUNC
        sqlite3ShowWindow(0);
        sqlite3ShowWinFunc(0);
#endif
        sqlite3ShowSelect(0);
      }
#endif
      break;
    }
 
 
    /*
    **  sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
    **
    ** This action provides a run-time test to see how the ALWAYS and
    ** NEVER macros were defined at compile-time.
    **
    ** The return value is ALWAYS(X) if X is true, or 0 if X is false.
    **
    ** The recommended test is X==2.  If the return value is 2, that means
    ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
    ** default setting.  If the return value is 1, then ALWAYS() is either
    ** hard-coded to true or else it asserts if its argument is false.
    ** The first behavior (hard-coded to true) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
    ** behavior (assert if the argument to ALWAYS() is false) is the case if
    ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
    **
    ** The run-time test procedure might look something like this:
    **
    **    if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
    **      // ALWAYS() and NEVER() are no-op pass-through macros
    **    }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
    **      // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
    **    }else{
    **      // ALWAYS(x) is a constant 1.  NEVER(x) is a constant 0.
    **    }
    */
    case SQLITE_TESTCTRL_ALWAYS: {
      int x = va_arg(ap,int);
      rc = x ? ALWAYS(x) : 0;
      break;
    }
 
    /*
    **   sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
    **
    ** The integer returned reveals the byte-order of the computer on which
    ** SQLite is running:
    **
    **       1     big-endian,    determined at run-time
    **      10     little-endian, determined at run-time
    **  432101     big-endian,    determined at compile-time
    **  123410     little-endian, determined at compile-time
    */
    case SQLITE_TESTCTRL_BYTEORDER: {
      rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
    **
    ** Enable or disable various optimizations for testing purposes.  The
    ** argument N is a bitmask of optimizations to be disabled.  For normal
    ** operation N should be 0.  The idea is that a test program (like the
    ** SQL Logic Test or SLT test module) can run the same SQL multiple times
    ** with various optimizations disabled to verify that the same answer
    ** is obtained in every case.
    */
    case SQLITE_TESTCTRL_OPTIMIZATIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->dbOptFlags = va_arg(ap, u32);
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_GETOPT, sqlite3 *db, int *N)
    **
    ** Write the current optimization settings into *N.  A zero bit means that
    ** the optimization is on, and a 1 bit means that the optimization is off.
    */
    case SQLITE_TESTCTRL_GETOPT: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      int *pN = va_arg(ap, int*);
      *pN = db->dbOptFlags;
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, onoff, xAlt);
    **
    ** If parameter onoff is 1, subsequent calls to localtime() fail.
    ** If 2, then invoke xAlt() instead of localtime().  If 0, normal
    ** processing.
    **
    ** xAlt arguments are void pointers, but they really want to be:
    **
    **    int xAlt(const time_t*, struct tm*);
    **
    ** xAlt should write results in to struct tm object of its 2nd argument
    ** and return zero on success, or return non-zero on failure.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      if( sqlite3GlobalConfig.bLocaltimeFault==2 ){
        typedef int(*sqlite3LocaltimeType)(const void*,void*);
        sqlite3GlobalConfig.xAltLocaltime = va_arg(ap, sqlite3LocaltimeType);
      }else{
        sqlite3GlobalConfig.xAltLocaltime = 0;
      }
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, sqlite3*);
    **
    ** Toggle the ability to use internal functions on or off for
    ** the database connection given in the argument.
    */
    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->mDbFlags ^= DBFLAG_InternalFunc;
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
    **
    ** Set or clear a flag that indicates that the database file is always well-
    ** formed and never corrupt.  This flag is clear by default, indicating that
    ** database files might have arbitrary corruption.  Setting the flag during
    ** testing causes certain assert() statements in the code to be activated
    ** that demonstrate invariants on well-formed database files.
    */
    case SQLITE_TESTCTRL_NEVER_CORRUPT: {
      sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, int);
    **
    ** Set or clear a flag that causes SQLite to verify that type, name,
    ** and tbl_name fields of the sqlite_schema table.  This is normally
    ** on, but it is sometimes useful to turn it off for testing.
    **
    ** 2020-07-22:  Disabling EXTRA_SCHEMA_CHECKS also disables the
    ** verification of rootpage numbers when parsing the schema.  This
    ** is useful to make it easier to reach strange internal error states
    ** during testing.  The EXTRA_SCHEMA_CHECKS setting is always enabled
    ** in production.
    */
    case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: {
      sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int);
      break;
    }
 
    /* Set the threshold at which OP_Once counters reset back to zero.
    ** By default this is 0x7ffffffe (over 2 billion), but that value is
    ** too big to test in a reasonable amount of time, so this control is
    ** provided to set a small and easily reachable reset value.
    */
    case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: {
      sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
    **
    ** Set the VDBE coverage callback function to xCallback with context
    ** pointer ptr.
    */
    case SQLITE_TESTCTRL_VDBE_COVERAGE: {
#ifdef SQLITE_VDBE_COVERAGE
      typedef void (*branch_callback)(void*,unsigned int,
                                      unsigned char,unsigned char);
      sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
      sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
#endif
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
    case SQLITE_TESTCTRL_SORTER_MMAP: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->nMaxSorterMmap = va_arg(ap, int);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
    **
    ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
    ** not.
    */
    case SQLITE_TESTCTRL_ISINIT: {
      if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
    **
    ** This test control is used to create imposter tables.  "db" is a pointer
    ** to the database connection.  dbName is the database name (ex: "main" or
    ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
    ** or off.  "tnum" is the root page of the b-tree to which the imposter
    ** table should connect.
    **
    ** Enable imposter mode only when the schema has already been parsed.  Then
    ** run a single CREATE TABLE statement to construct the imposter table in
    ** the parsed schema.  Then turn imposter mode back off again.
    **
    ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
    ** the schema to be reparsed the next time it is needed.  This has the
    ** effect of erasing all imposter tables.
    */
    case SQLITE_TESTCTRL_IMPOSTER: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      int iDb;
      sqlite3_mutex_enter(db->mutex);
      iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
      if( iDb>=0 ){
        db->init.iDb = iDb;
        db->init.busy = db->init.imposterTable = va_arg(ap,int);
        db->init.newTnum = va_arg(ap,int);
        if( db->init.busy==0 && db->init.newTnum>0 ){
          sqlite3ResetAllSchemasOfConnection(db);
        }
      }
      sqlite3_mutex_leave(db->mutex);
      break;
    }
 
#if defined(YYCOVERAGE)
    /*  sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
    **
    ** This test control (only available when SQLite is compiled with
    ** -DYYCOVERAGE) writes a report onto "out" that shows all
    ** state/lookahead combinations in the parser state machine
    ** which are never exercised.  If any state is missed, make the
    ** return code SQLITE_ERROR.
    */
    case SQLITE_TESTCTRL_PARSER_COVERAGE: {
      FILE *out = va_arg(ap, FILE*);
      if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR;
      break;
    }
#endif /* defined(YYCOVERAGE) */
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*);
    **
    ** This test-control causes the most recent sqlite3_result_int64() value
    ** to be interpreted as a MEM_IntReal instead of as an MEM_Int.  Normally,
    ** MEM_IntReal values only arise during an INSERT operation of integer
    ** values into a REAL column, so they can be challenging to test.  This
    ** test-control enables us to write an intreal() SQL function that can
    ** inject an intreal() value at arbitrary places in an SQL statement,
    ** for testing purposes.
    */
    case SQLITE_TESTCTRL_RESULT_INTREAL: {
      sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
      sqlite3ResultIntReal(pCtx);
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_SEEK_COUNT,
    **    sqlite3 *db,    // Database connection
    **    u64 *pnSeek     // Write seek count here
    **  );
    **
    ** This test-control queries the seek-counter on the "main" database
    ** file.  The seek-counter is written into *pnSeek and is then reset.
    ** The seek-count is only available if compiled with SQLITE_DEBUG.
    */
    case SQLITE_TESTCTRL_SEEK_COUNT: {
      sqlite3 *db = va_arg(ap, sqlite3*);
      u64 *pn = va_arg(ap, sqlite3_uint64*);
      *pn = sqlite3BtreeSeekCount(db->aDb->pBt);
      (void)db;  /* Silence harmless unused variable warning */
      break;
    }
 
    /*  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, op, ptr)
    **
    **  "ptr" is a pointer to a u32.
    **
    **   op==0       Store the current sqlite3TreeTrace in *ptr
    **   op==1       Set sqlite3TreeTrace to the value *ptr
    **   op==2       Store the current sqlite3WhereTrace in *ptr
    **   op==3       Set sqlite3WhereTrace to the value *ptr
    */
    case SQLITE_TESTCTRL_TRACEFLAGS: {
       int opTrace = va_arg(ap, int);
       u32 *ptr = va_arg(ap, u32*);
       switch( opTrace ){
         case 0:   *ptr = sqlite3TreeTrace;      break;
         case 1:   sqlite3TreeTrace = *ptr;      break;
         case 2:   *ptr = sqlite3WhereTrace;     break;
         case 3:   sqlite3WhereTrace = *ptr;     break;
       }
       break;
    }
 
    /* sqlite3_test_control(SQLITE_TESTCTRL_LOGEST,
    **      double fIn,     // Input value
    **      int *pLogEst,   // sqlite3LogEstFromDouble(fIn)
    **      u64 *pInt,      // sqlite3LogEstToInt(*pLogEst)
    **      int *pLogEst2   // sqlite3LogEst(*pInt)
    ** );
    **
    ** Test access for the LogEst conversion routines.
    */
    case SQLITE_TESTCTRL_LOGEST: {
      double rIn = va_arg(ap, double);
      LogEst rLogEst = sqlite3LogEstFromDouble(rIn);
      int *pI1 = va_arg(ap,int*);
      u64 *pU64 = va_arg(ap,u64*);
      int *pI2 = va_arg(ap,int*);
      *pI1 = rLogEst;
      *pU64 = sqlite3LogEstToInt(rLogEst);
      *pI2 = sqlite3LogEst(*pU64);
      break;
    }
 
#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
    /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
    **
    ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
    ** of the id-th tuning parameter to *piValue.  If "id" is between -1
    ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
    ** tuning parameter into *piValue.
    **
    ** Tuning parameters are for use during transient development builds,
    ** to help find the best values for constants in the query planner.
    ** Access tuning parameters using the Tuning(ID) macro.  Set the
    ** parameters in the CLI using ".testctrl tune ID VALUE".
    **
    ** Transient use only.  Tuning parameters should not be used in
    ** checked-in code.
    */
    case SQLITE_TESTCTRL_TUNE: {
      int id = va_arg(ap, int);
      int *piValue = va_arg(ap, int*);
      if( id>0 && id<=SQLITE_NTUNE ){
        Tuning(id) = *piValue;
      }else if( id<0 && id>=-SQLITE_NTUNE ){
        *piValue = Tuning(-id);
      }else{
        rc = SQLITE_NOTFOUND;
      }
      break;
    }
#endif
 
    /* sqlite3_test_control(SQLITE_TESTCTRL_JSON_SELFCHECK, &onOff);
    **
    ** Activate or deactivate validation of JSONB that is generated from
    ** text.  Off by default, as the validation is slow.  Validation is
    ** only available if compiled using SQLITE_DEBUG.
    **
    ** If onOff is initially 1, then turn it on.  If onOff is initially
    ** off, turn it off.  If onOff is initially -1, then change onOff
    ** to be the current setting.
    */
    case SQLITE_TESTCTRL_JSON_SELFCHECK: {
#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
      int *pOnOff = va_arg(ap, int*);
      if( *pOnOff<0 ){
        *pOnOff = sqlite3Config.bJsonSelfcheck;
      }else{
        sqlite3Config.bJsonSelfcheck = (u8)((*pOnOff)&0xff);
      }
#endif

◆ sqlite3_thread_cleanup()

void sqlite3_thread_cleanup ( void )

References SQLITE_API.

◆ sqlite3_threadsafe()

int sqlite3_threadsafe ( void )

References SQLITE_API, and SQLITE_VERSION_NUMBER.

◆ sqlite3_total_changes()

int sqlite3_total_changes ( sqlite3 * db )

                                 {
    (void)SQLITE_MISUSE_BKPT;
    return 0;

References SQLITE_MISUSE_BKPT.

◆ sqlite3_total_changes64()

sqlite3_int64 sqlite3_total_changes64 ( sqlite3 * db )

                                           {
  return (int)sqlite3_changes64(db);
}
 
/*
** Return the number of changes since the database handle was opened.
*/
SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3 *db){
#ifdef SQLITE_ENABLE_API_ARMOR

References sqlite3_changes64, and SQLITE_API.

◆ sqlite3_trace()

void * sqlite3_trace	(	sqlite3 *	db,
		void(*	xTrace )(void , const char ),
		void *	pArg )

                                                                                         {
  void *pOld;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);

References sqlite3::mTrace, sqlite3::mutex, sqlite3::pTraceArg, sqlite3_mutex_enter, sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_TRACE_LEGACY, and sqlite3::trace.

Here is the call graph for this function:

◆ sqlite3_trace_v2()

int sqlite3_trace_v2	(	sqlite3 *	db,
		unsigned	uMask,
		int(*	xCallback )(unsigned, void , void , void *),
		void *	pCtx )

 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( mTrace==0 ) xTrace = 0;

◆ sqlite3_transfer_bindings()

int sqlite3_transfer_bindings	(	sqlite3_stmt *	pFromStmt,
		sqlite3_stmt *	pToStmt )

                                                                                        {
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  if( pFrom->nVar!=pTo->nVar ){
    return SQLITE_ERROR;
  }
  assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
  if( pTo->expmask ){
    pTo->expired = 1;
  }

References Vdbe::expired, Vdbe::expmask, Vdbe::nVar, Vdbe::prepFlags, sqlite3TransferBindings(), SQLITE_API, SQLITE_ERROR, and SQLITE_PREPARE_SAVESQL.

Here is the call graph for this function:

◆ sqlite3_txn_state()

int sqlite3_txn_state	(	sqlite3 *	db,
		const char *	zSchema )

                                                                  {
  int iDb, nDb;
  int iTxn = -1;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return -1;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( zSchema ){
    nDb = iDb = sqlite3FindDbName(db, zSchema);
    if( iDb<0 ) nDb--;
  }else{
    iDb = 0;
    nDb = db->nDb-1;
  }
  for(; iDb<=nDb; iDb++){

References SQLITE_OK.

◆ sqlite3_unlock_notify()

int sqlite3_unlock_notify	(	sqlite3 *	pBlocked,
		void(*	xNotify )(void **apArg, int nArg),
		void *	pNotifyArg )

References SQLITE_API.

◆ sqlite3_update_hook()

void * sqlite3_update_hook	(	sqlite3 *	db,
		void(*	xCallback )(void , int, char const , char const *, sqlite3_int64),
		void *	pArg )

 {
  void *pRet;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif

◆ sqlite3_uri_boolean()

int sqlite3_uri_boolean	(	sqlite3_filename	z,
		const char *	zParam,
		int	bDefault )

◆ sqlite3_uri_int64()

sqlite3_int64 sqlite3_uri_int64	(	sqlite3_filename	zFilename,
		const char *	zParam,
		sqlite3_int64	bDflt )

                                         : bDflt;
}
 
/*
** Return a 64-bit integer value for a query parameter.
*/
SQLITE_API sqlite3_int64 sqlite3_uri_int64(
  const char *zFilename,    /* Filename as passed to xOpen */
  const char *zParam,       /* URI parameter sought */
  sqlite3_int64 bDflt       /* return if parameter is missing */
){

◆ sqlite3_uri_key()

const char * sqlite3_uri_key	(	sqlite3_filename	z,
		int	N )

                                                                    {
  if( zFilename==0 || N<0 ) return 0;
  zFilename = databaseName(zFilename);

◆ sqlite3_uri_parameter()

const char * sqlite3_uri_parameter	(	sqlite3_filename	z,
		const char *	zParam )

References SQLITE_API.

◆ sqlite3_user_data()

void * sqlite3_user_data ( sqlite3_context * p )

92408 {

References sqlite3_context::pFunc, FuncDef::pUserData, and SQLITE_API.

◆ sqlite3_value_blob()

const void * sqlite3_value_blob ( sqlite3_value * pVal )

                                                              {
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(p)!=SQLITE_OK ){
      assert( p->flags==MEM_Null && p->z==0 );
      return 0;
    }

References ExpandBlob, sqlite3_value::flags, MEM_Blob, MEM_Null, MEM_Str, SQLITE_API, SQLITE_OK, and sqlite3_value::z.

◆ sqlite3_value_bytes()

int sqlite3_value_bytes ( sqlite3_value * pVal )

91649 : 0;

91650 }else{

References MEM_Blob.

◆ sqlite3_value_bytes16()

int sqlite3_value_bytes16 ( sqlite3_value * pVal )

◆ sqlite3_value_double()

double sqlite3_value_double ( sqlite3_value * pVal )

                                                       {
  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
}

References sqlite3ValueBytes(), SQLITE_API, and SQLITE_UTF8.

Here is the call graph for this function:

◆ sqlite3_value_dup()

sqlite3_value * sqlite3_value_dup ( const sqlite3_value * pOrig )

                                                          {
  return (pVal->flags&MEM_FromBind)!=0;
}
 
/* Make a copy of an sqlite3_value object
*/
SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
  sqlite3_value *pNew;
  if( pOrig==0 ) return 0;
  pNew = sqlite3_malloc( sizeof(*pNew) );
  if( pNew==0 ) return 0;
  memset(pNew, 0, sizeof(*pNew));
  memcpy(pNew, pOrig, MEMCELLSIZE);
  pNew->flags &= ~MEM_Dyn;
  pNew->db = 0;
  if( pNew->flags&(MEM_Str|MEM_Blob) ){
    pNew->flags &= ~(MEM_Static|MEM_Dyn);
    pNew->flags |= MEM_Ephem;
    if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
      sqlite3ValueFree(pNew);
      pNew = 0;
    }

References sqlite3_value::flags, MEM_FromBind, and SQLITE_API.

◆ sqlite3_value_encoding()

int sqlite3_value_encoding ( sqlite3_value * pVal )

◆ sqlite3_value_free()

void sqlite3_value_free ( sqlite3_value * pOld )

◆ sqlite3_value_frombind()

int sqlite3_value_frombind ( sqlite3_value * pVal )

91793 {

91794 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);

References sqlite3_value::flags, MEM_Null, MEM_Zero, and SQLITE_API.

◆ sqlite3_value_int()

int sqlite3_value_int ( sqlite3_value * pVal )

                                                         {
  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueBytes(), SQLITE_API, and SQLITE_UTF16NATIVE.

Here is the call graph for this function:

◆ sqlite3_value_int64()

sqlite3_int64 sqlite3_value_int64 ( sqlite3_value * pVal )

                                                           {
  return sqlite3VdbeRealValue((Mem*)pVal);
}

References sqlite3VdbeRealValue(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_value_nochange()

int sqlite3_value_nochange ( sqlite3_value * pVal )

91788 {

91789 return pVal->enc;

◆ sqlite3_value_numeric_type()

int sqlite3_value_numeric_type ( sqlite3_value * pVal )

                                                              {
  int eType = sqlite3_value_type(pVal);
  if( eType==SQLITE_TEXT ){

References applyNumericAffinity(), sqlite3_value_type, SQLITE_API, and SQLITE_TEXT.

Here is the call graph for this function:

◆ sqlite3_value_pointer()

void * sqlite3_value_pointer	(	sqlite3_value *	pVal,
		const char *	zPType )

                                                                  {
  Mem *pMem = (Mem*)pVal;
  return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
}
SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
  Mem *p = (Mem*)pVal;
  if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
                 (MEM_Null|MEM_Term|MEM_Subtype)
   && zPType!=0
   && p->eSubtype=='p'
   && strcmp(p->u.zPType, zPType)==0

◆ sqlite3_value_subtype()

unsigned int sqlite3_value_subtype ( sqlite3_value * pVal )

                                                     {
  return (int)sqlite3VdbeIntValue((Mem*)pVal);
}
SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

References sqlite3VdbeIntValue(), and SQLITE_API.

Here is the call graph for this function:

◆ sqlite3_value_text()

const unsigned char * sqlite3_value_text ( sqlite3_value * pVal )

   {
    return (void*)p->z;
  }else{

References sqlite3_value::z.

◆ sqlite3_value_text16()

const void * sqlite3_value_text16 ( sqlite3_value * pVal )

91686 {

◆ sqlite3_value_text16be()

const void * sqlite3_value_text16be ( sqlite3_value * pVal )

References SQLITE_UTF8.

◆ sqlite3_value_text16le()

const void * sqlite3_value_text16le ( sqlite3_value * pVal )

                                                                {
  return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueText(), SQLITE_API, and SQLITE_UTF16NATIVE.

Here is the call graph for this function:

◆ sqlite3_value_type()

int sqlite3_value_type ( sqlite3_value * pVal )

                                                      {
  static const u8 aType[] = {
     SQLITE_BLOB,     /* 0x00 (not possible) */
     SQLITE_NULL,     /* 0x01 NULL */
     SQLITE_TEXT,     /* 0x02 TEXT */
     SQLITE_NULL,     /* 0x03 (not possible) */
     SQLITE_INTEGER,  /* 0x04 INTEGER */
     SQLITE_NULL,     /* 0x05 (not possible) */
     SQLITE_INTEGER,  /* 0x06 INTEGER + TEXT */
     SQLITE_NULL,     /* 0x07 (not possible) */
     SQLITE_FLOAT,    /* 0x08 FLOAT */
     SQLITE_NULL,     /* 0x09 (not possible) */
     SQLITE_FLOAT,    /* 0x0a FLOAT + TEXT */
     SQLITE_NULL,     /* 0x0b (not possible) */
     SQLITE_INTEGER,  /* 0x0c (not possible) */
     SQLITE_NULL,     /* 0x0d (not possible) */
     SQLITE_INTEGER,  /* 0x0e (not possible) */
     SQLITE_NULL,     /* 0x0f (not possible) */
     SQLITE_BLOB,     /* 0x10 BLOB */
     SQLITE_NULL,     /* 0x11 (not possible) */
     SQLITE_TEXT,     /* 0x12 (not possible) */
     SQLITE_NULL,     /* 0x13 (not possible) */
     SQLITE_INTEGER,  /* 0x14 INTEGER + BLOB */
     SQLITE_NULL,     /* 0x15 (not possible) */
     SQLITE_INTEGER,  /* 0x16 (not possible) */
     SQLITE_NULL,     /* 0x17 (not possible) */
     SQLITE_FLOAT,    /* 0x18 FLOAT + BLOB */
     SQLITE_NULL,     /* 0x19 (not possible) */
     SQLITE_FLOAT,    /* 0x1a (not possible) */
     SQLITE_NULL,     /* 0x1b (not possible) */
     SQLITE_INTEGER,  /* 0x1c (not possible) */
     SQLITE_NULL,     /* 0x1d (not possible) */
     SQLITE_INTEGER,  /* 0x1e (not possible) */
     SQLITE_NULL,     /* 0x1f (not possible) */
     SQLITE_FLOAT,    /* 0x20 INTREAL */
     SQLITE_NULL,     /* 0x21 (not possible) */
     SQLITE_FLOAT,    /* 0x22 INTREAL + TEXT */
     SQLITE_NULL,     /* 0x23 (not possible) */
     SQLITE_FLOAT,    /* 0x24 (not possible) */
     SQLITE_NULL,     /* 0x25 (not possible) */
     SQLITE_FLOAT,    /* 0x26 (not possible) */
     SQLITE_NULL,     /* 0x27 (not possible) */
     SQLITE_FLOAT,    /* 0x28 (not possible) */
     SQLITE_NULL,     /* 0x29 (not possible) */
     SQLITE_FLOAT,    /* 0x2a (not possible) */
     SQLITE_NULL,     /* 0x2b (not possible) */
     SQLITE_FLOAT,    /* 0x2c (not possible) */
     SQLITE_NULL,     /* 0x2d (not possible) */
     SQLITE_FLOAT,    /* 0x2e (not possible) */
     SQLITE_NULL,     /* 0x2f (not possible) */
     SQLITE_BLOB,     /* 0x30 (not possible) */
     SQLITE_NULL,     /* 0x31 (not possible) */
     SQLITE_TEXT,     /* 0x32 (not possible) */
     SQLITE_NULL,     /* 0x33 (not possible) */
     SQLITE_FLOAT,    /* 0x34 (not possible) */
     SQLITE_NULL,     /* 0x35 (not possible) */
     SQLITE_FLOAT,    /* 0x36 (not possible) */
     SQLITE_NULL,     /* 0x37 (not possible) */
     SQLITE_FLOAT,    /* 0x38 (not possible) */
     SQLITE_NULL,     /* 0x39 (not possible) */
     SQLITE_FLOAT,    /* 0x3a (not possible) */
     SQLITE_NULL,     /* 0x3b (not possible) */
     SQLITE_FLOAT,    /* 0x3c (not possible) */
     SQLITE_NULL,     /* 0x3d (not possible) */
     SQLITE_FLOAT,    /* 0x3e (not possible) */
     SQLITE_NULL,     /* 0x3f (not possible) */
  };
#ifdef SQLITE_DEBUG
  {
    int eType = SQLITE_BLOB;
    if( pVal->flags & MEM_Null ){
      eType = SQLITE_NULL;
    }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
      eType = SQLITE_FLOAT;
    }else if( pVal->flags & MEM_Int ){
      eType = SQLITE_INTEGER;
    }else if( pVal->flags & MEM_Str ){
      eType = SQLITE_TEXT;

◆ sqlite3_vfs_find()

sqlite3_vfs * sqlite3_vfs_find ( const char * zVfsName )

                                                          {
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;

References sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3MutexAlloc(), SQLITE_API, SQLITE_MUTEX_STATIC_MAIN, vfsList, and sqlite3_vfs::zName.

Here is the call graph for this function:

◆ sqlite3_vfs_register()

int sqlite3_vfs_register	(	sqlite3_vfs *	pVfs,
		int	makeDflt )

                                                                    {
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
#endif
 
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;

References MUTEX_LOGIC, sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3MutexAlloc(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_MUTEX_STATIC_MAIN, SQLITE_OK, vfsList, and vfsUnlink().

Here is the call graph for this function:

◆ sqlite3_vfs_unregister()

int sqlite3_vfs_unregister ( sqlite3_vfs * pVfs )

                                                        {
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )

◆ sqlite3_vmprintf()

char * sqlite3_vmprintf	(	const char *	zFormat,
		va_list	ap )

                                                                  {
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zFormat==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;

◆ sqlite3_vsnprintf()

char * sqlite3_vsnprintf	(	int	n,
		char *	zBuf,
		const char *	zFormat,
		va_list	ap )

                                                                                      {
  StrAccum acc;
  if( n<=0 ) return zBuf;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zBuf==0 || zFormat==0 ) {
    (void)SQLITE_MISUSE_BKPT;
    if( zBuf ) zBuf[0] = 0;
    return zBuf;
  }

References SQLITE_API, and SQLITE_MISUSE_BKPT.

◆ sqlite3_vtab_collation()

const char * sqlite3_vtab_collation	(	sqlite3_index_info *	pIdxInfo,
		int	iCons )

                                                                                      {
  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
  const char *zRet = 0;
  if( iCons>=0 && iCons<pIdxInfo->nConstraint ){
    CollSeq *pC = 0;
    int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
    Expr *pX = termFromWhereClause(pHidden->pWC, iTerm)->pExpr;

References sqlite3_index_info::aConstraint, sqlite3_index_info::sqlite3_index_constraint::iTermOffset, WhereTerm::pExpr, Expr::pLeft, HiddenIndexInfo::pParse, HiddenIndexInfo::pWC, sqlite3ExprCompareCollSeq(), sqlite3StrBINARY, SQLITE_API, termFromWhereClause(), and CollSeq::zName.

Here is the call graph for this function:

◆ sqlite3_vtab_config()

int sqlite3_vtab_config	(	sqlite3 *	db,
		int	op,
			... )

                                                            {
  va_list ap;
  int rc = SQLITE_OK;
  VtabCtx *p;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  p = db->pVtabCtx;
  if( !p ){
    rc = SQLITE_MISUSE_BKPT;
  }else{
    assert( p->pTab==0 || IsVirtual(p->pTab) );
    va_start(ap, op);
    switch( op ){
      case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
        p->pVTable->bConstraint = (u8)va_arg(ap, int);
        break;
      }
      case SQLITE_VTAB_INNOCUOUS: {
        p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low;
        break;
      }
      case SQLITE_VTAB_DIRECTONLY: {
        p->pVTable->eVtabRisk = SQLITE_VTABRISK_High;
        break;
      }
      case SQLITE_VTAB_USES_ALL_SCHEMAS: {
        p->pVTable->bAllSchemas = 1;
        break;
      }
      default: {
        rc = SQLITE_MISUSE_BKPT;
        break;
      }
    }
    va_end(ap);

References VTable::bAllSchemas, VTable::bConstraint, VTable::eVtabRisk, IsVirtual, sqlite3::mutex, VtabCtx::pTab, sqlite3::pVtabCtx, VtabCtx::pVTable, sqlite3_mutex_enter, sqlite3_mutex_leave, sqlite3Error(), sqlite3SafetyCheckOk(), SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_OK, SQLITE_VTAB_CONSTRAINT_SUPPORT, SQLITE_VTAB_DIRECTONLY, SQLITE_VTAB_INNOCUOUS, SQLITE_VTAB_USES_ALL_SCHEMAS, SQLITE_VTABRISK_High, and SQLITE_VTABRISK_Low.

Here is the call graph for this function:

◆ sqlite3_vtab_distinct()

int sqlite3_vtab_distinct ( sqlite3_index_info * pIdxInfo )

◆ sqlite3_vtab_in()

int sqlite3_vtab_in	(	sqlite3_index_info *	pIdxInfo,
		int	iCons,
		int	bHandle )

                                                                                    {
  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
  u32 m = SMASKBIT32(iCons);
  if( m & pHidden->mIn ){
    if( bHandle==0 ){
      pHidden->mHandleIn &= ~m;

◆ sqlite3_vtab_in_first()

int sqlite3_vtab_in_first	(	sqlite3_value *	pVal,
		sqlite3_value **	ppOut )

◆ sqlite3_vtab_in_next()

int sqlite3_vtab_in_next	(	sqlite3_value *	pVal,
		sqlite3_value **	ppOut )

◆ sqlite3_vtab_nochange()

int sqlite3_vtab_nochange ( sqlite3_context * p )

92449 {

92450#ifdef SQLITE_ENABLE_API_ARMOR

References sqlite3_context::pOut, sqlite3_value_nochange, and SQLITE_API.

◆ sqlite3_vtab_on_conflict()

int sqlite3_vtab_on_conflict ( sqlite3 * db )

                                                    {
  static const unsigned char aMap[] = {
    SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
  };
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;

References OE_Abort, OE_Fail, OE_Ignore, OE_Replace, OE_Rollback, sqlite3SafetyCheckOk(), SQLITE_ABORT, SQLITE_API, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_MISUSE_BKPT, SQLITE_REPLACE, SQLITE_ROLLBACK, and sqlite3::vtabOnConflict.

Here is the call graph for this function:

◆ sqlite3_vtab_rhs_value()

int sqlite3_vtab_rhs_value	(	sqlite3_index_info *	pIdxInfo,
		int	iCons,
		sqlite3_value **	ppVal )

 {
  HiddenIndexInfo *pH = (HiddenIndexInfo*)&pIdxInfo[1];
  sqlite3_value *pVal = 0;
  int rc = SQLITE_OK;
  if( iCons<0 || iCons>=pIdxInfo->nConstraint ){
    rc = SQLITE_MISUSE_BKPT; /* EV: R-30545-25046 */
  }else{
    if( pH->aRhs[iCons]==0 ){
      WhereTerm *pTerm = termFromWhereClause(
          pH->pWC, pIdxInfo->aConstraint[iCons].iTermOffset
      );
      rc = sqlite3ValueFromExpr(
          pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
          SQLITE_AFF_BLOB, &pH->aRhs[iCons]
      );
      testcase( rc!=SQLITE_OK );
    }
    pVal = pH->aRhs[iCons];
  }
  *ppVal = pVal;

References sqlite3_index_info::aConstraint, HiddenIndexInfo::aRhs, Parse::db, ENC, sqlite3_index_info::sqlite3_index_constraint::iTermOffset, sqlite3_index_info::nConstraint, WhereTerm::pExpr, HiddenIndexInfo::pParse, Expr::pRight, HiddenIndexInfo::pWC, sqlite3ValueFromExpr(), SQLITE_AFF_BLOB, SQLITE_API, SQLITE_MISUSE_BKPT, SQLITE_NOTFOUND, SQLITE_OK, termFromWhereClause(), and testcase.

Here is the call graph for this function:

◆ sqlite3_wal_autocheckpoint()

int sqlite3_wal_autocheckpoint	(	sqlite3 *	db,
		int	N )

                                                                  {
#ifdef SQLITE_OMIT_WAL
  UNUSED_PARAMETER(db);
  UNUSED_PARAMETER(nFrame);
#else
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( nFrame>0 ){

References sqlite3_wal_hook, sqlite3SafetyCheckOk(), sqlite3WalDefaultHook(), SQLITE_API, SQLITE_INT_TO_PTR, SQLITE_MISUSE_BKPT, and UNUSED_PARAMETER.

Here is the call graph for this function:

◆ sqlite3_wal_checkpoint()

int sqlite3_wal_checkpoint	(	sqlite3 *	db,
		const char *	zDb )

References sqlite3_wal_checkpoint_v2, SQLITE_API, and SQLITE_CHECKPOINT_PASSIVE.

◆ sqlite3_wal_checkpoint_v2()

int sqlite3_wal_checkpoint_v2	(	sqlite3 *	db,
		const char *	zDb,
		int	eMode,
		int *	pnLog,
		int *	pnCkpt )

 {
#ifdef SQLITE_OMIT_WAL
  return SQLITE_OK;
#else
  int rc;                         /* Return code */
  int iDb;                        /* Schema to checkpoint */
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
 
  /* Initialize the output variables to -1 in case an error occurs. */
  if( pnLog ) *pnLog = -1;
  if( pnCkpt ) *pnCkpt = -1;
 
  assert( SQLITE_CHECKPOINT_PASSIVE==0 );
  assert( SQLITE_CHECKPOINT_FULL==1 );
  assert( SQLITE_CHECKPOINT_RESTART==2 );
  assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
  if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
    /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
    ** mode: */
    return SQLITE_MISUSE_BKPT;
  }
 
  sqlite3_mutex_enter(db->mutex);
  if( zDb && zDb[0] ){
    iDb = sqlite3FindDbName(db, zDb);
  }else{
    iDb = SQLITE_MAX_DB;   /* This means process all schemas */
  }
  if( iDb<0 ){
    rc = SQLITE_ERROR;
    sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
  }else{
    db->busyHandler.nBusy = 0;
    rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
    sqlite3Error(db, rc);
  }
  rc = sqlite3ApiExit(db, rc);
 
  /* If there are no active statements, clear the interrupt flag at this
  ** point.  */
  if( db->nVdbeActive==0 ){

◆ sqlite3_wal_hook()

void * sqlite3_wal_hook	(	sqlite3 *	db,
		int(*	xCallback )(void , sqlite3 , const char *, int),
		void *	pArg )

 {
#ifndef SQLITE_OMIT_WAL
  void *pRet;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pWalArg;
  db->xWalCallback = xCallback;

References SQLITE_OK.

◆ sqlite3_win32_set_directory()

int sqlite3_win32_set_directory	(	unsigned long	type,
		void *	zValue )

References SQLITE_API.

◆ sqlite3_win32_set_directory16()

int sqlite3_win32_set_directory16	(	unsigned long	type,
		const void *	zValue )

References SQLITE_API.

◆ sqlite3_win32_set_directory8()

int sqlite3_win32_set_directory8	(	unsigned long	type,
		const char *	zValue )

References SQLITE_API.

Variable Documentation

◆ sqlite3_data_directory

char* sqlite3_data_directory

extern

Referenced by sqlite3_shutdown(), and sqlite3Pragma().

◆ sqlite3_temp_directory

char* sqlite3_temp_directory

extern

Referenced by sqlite3_shutdown(), and sqlite3Pragma().

◆ sqlite3_version

const char sqlite3_version[]

extern

Referenced by sqlite3_libversion().

Data Structures

Macros

Typedefs

Functions

Variables

Data Structure Documentation

◆ sqlite3_file

◆ sqlite3_io_methods

◆ sqlite3_vfs

◆ sqlite3_mem_methods

◆ sqlite3_module

◆ sqlite3_index_info

◆ sqlite3_index_info::sqlite3_index_constraint

◆ sqlite3_index_info::sqlite3_index_orderby

◆ sqlite3_index_info::sqlite3_index_constraint_usage

◆ sqlite3_vtab

◆ sqlite3_vtab_cursor

◆ sqlite3_mutex_methods

◆ sqlite3_pcache_page

◆ sqlite3_pcache_methods2

◆ sqlite3_pcache_methods

◆ sqlite3_snapshot

◆ sqlite3_rtree_geometry

◆ sqlite3_rtree_query_info

◆ Fts5PhraseIter

◆ Fts5ExtensionApi

◆ fts5_tokenizer_v2

◆ fts5_tokenizer

◆ fts5_api

Macro Definition Documentation

◆ _FTS5_H

◆ _SQLITE3RTREE_H_

◆ FTS5_TOKEN_COLOCATED

◆ FTS5_TOKENIZE_AUX

◆ FTS5_TOKENIZE_DOCUMENT

◆ FTS5_TOKENIZE_PREFIX

◆ FTS5_TOKENIZE_QUERY

◆ FULLY_WITHIN

◆ NOT_WITHIN

◆ PARTLY_WITHIN

◆ SQLITE3_TEXT

◆ SQLITE_ABORT

◆ SQLITE_ABORT_ROLLBACK

◆ SQLITE_ACCESS_EXISTS

◆ SQLITE_ACCESS_READ

◆ SQLITE_ACCESS_READWRITE

◆ SQLITE_ALTER_TABLE

◆ SQLITE_ANALYZE

◆ SQLITE_ANY

◆ SQLITE_API

◆ SQLITE_APICALL

◆ SQLITE_ATTACH

◆ SQLITE_AUTH

◆ SQLITE_AUTH_USER

◆ SQLITE_BLOB

◆ SQLITE_BUSY

◆ SQLITE_BUSY_RECOVERY

◆ SQLITE_BUSY_SNAPSHOT

◆ SQLITE_BUSY_TIMEOUT

◆ SQLITE_CALLBACK

◆ SQLITE_CANTOPEN

◆ SQLITE_CANTOPEN_CONVPATH

◆ SQLITE_CANTOPEN_DIRTYWAL

◆ SQLITE_CANTOPEN_FULLPATH

◆ SQLITE_CANTOPEN_ISDIR

◆ SQLITE_CANTOPEN_NOTEMPDIR

◆ SQLITE_CANTOPEN_SYMLINK

◆ SQLITE_CDECL

◆ SQLITE_CHECKPOINT_FULL

◆ SQLITE_CHECKPOINT_PASSIVE

◆ SQLITE_CHECKPOINT_RESTART

◆ SQLITE_CHECKPOINT_TRUNCATE

◆ SQLITE_CONFIG_COVERING_INDEX_SCAN

◆ SQLITE_CONFIG_GETMALLOC

◆ SQLITE_CONFIG_GETMUTEX

◆ SQLITE_CONFIG_GETPCACHE

◆ SQLITE_CONFIG_GETPCACHE2

◆ SQLITE_CONFIG_HEAP

◆ SQLITE_CONFIG_LOG

◆ SQLITE_CONFIG_LOOKASIDE