#include <stdarg.h>

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

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.33.0"

#define	SQLITE_VERSION_NUMBER 3033000

#define	SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f"

#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_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_NOTICE_RECOVER_WAL (SQLITE_NOTICE \| (1<<8))

#define	SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE \| (2<<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))

#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_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_LOCK_NONE 0

#define	SQLITE_LOCK_SHARED 1

#define	SQLITE_LOCK_RESERVED 2

#define	SQLITE_LOCK_PENDING 3

#define	SQLITE_LOCK_EXCLUSIVE 4

#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_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_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_MAX 1017 /* Largest DBCONFIG */

#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_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_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_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */

#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_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_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_OPTIMIZATIONS 15

#define	SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */

#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_LAST 29 /* 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_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 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_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_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 struct sqlite3	sqlite3

typedef long long int	sqlite_int64

typedef unsigned long long int	sqlite_uint64

typedef sqlite_int64	sqlite3_int64

typedef sqlite_uint64	sqlite3_uint64

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

typedef struct sqlite3_file	sqlite3_file

typedef struct sqlite3_io_methods	sqlite3_io_methods

typedef struct sqlite3_mutex	sqlite3_mutex

typedef struct sqlite3_api_routines	sqlite3_api_routines

typedef struct sqlite3_vfs	sqlite3_vfs

typedef void(*	sqlite3_syscall_ptr) (void)

typedef struct sqlite3_mem_methods	sqlite3_mem_methods

typedef struct sqlite3_stmt	sqlite3_stmt

typedef struct sqlite3_value	sqlite3_value

typedef struct sqlite3_context	sqlite3_context

typedef void(*	sqlite3_destructor_type) (void *)

typedef struct sqlite3_vtab	sqlite3_vtab

typedef struct sqlite3_index_info	sqlite3_index_info

typedef struct sqlite3_vtab_cursor	sqlite3_vtab_cursor

typedef struct sqlite3_module	sqlite3_module

typedef struct sqlite3_blob	sqlite3_blob

typedef struct sqlite3_mutex_methods	sqlite3_mutex_methods

typedef struct sqlite3_str	sqlite3_str

typedef struct sqlite3_pcache	sqlite3_pcache

typedef struct sqlite3_pcache_page	sqlite3_pcache_page

typedef struct sqlite3_pcache_methods2	sqlite3_pcache_methods2

typedef struct sqlite3_pcache_methods	sqlite3_pcache_methods

typedef struct sqlite3_backup	sqlite3_backup

typedef struct sqlite3_snapshot	sqlite3_snapshot

typedef struct sqlite3_rtree_geometry	sqlite3_rtree_geometry

typedef struct sqlite3_rtree_query_info	sqlite3_rtree_query_info

typedef double	sqlite3_rtree_dbl

typedef struct Fts5ExtensionApi	Fts5ExtensionApi

typedef struct Fts5Context	Fts5Context

typedef struct Fts5PhraseIter	Fts5PhraseIter

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

typedef struct Fts5Tokenizer	Fts5Tokenizer

typedef struct fts5_tokenizer	fts5_tokenizer

typedef struct fts5_api	fts5_api

Functions
SQLITE_API const char *	sqlite3_libversion (void)

SQLITE_API const char *	sqlite3_sourceid (void)

SQLITE_API int	sqlite3_libversion_number (void)

SQLITE_API int	sqlite3_compileoption_used (const char *zOptName)

SQLITE_API const char *	sqlite3_compileoption_get (int N)

SQLITE_API int	sqlite3_threadsafe (void)

SQLITE_API int	sqlite3_close (sqlite3 *)

SQLITE_API int	sqlite3_close_v2 (sqlite3 *)

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

SQLITE_API int	sqlite3_initialize (void)

SQLITE_API int	sqlite3_shutdown (void)

SQLITE_API int	sqlite3_os_init (void)

SQLITE_API int	sqlite3_os_end (void)

SQLITE_API int	sqlite3_config (int,...)

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

SQLITE_API int	sqlite3_extended_result_codes (sqlite3 *, int onoff)

SQLITE_API sqlite3_int64	sqlite3_last_insert_rowid (sqlite3 *)

SQLITE_API void	sqlite3_set_last_insert_rowid (sqlite3 *, sqlite3_int64)

SQLITE_API int	sqlite3_changes (sqlite3 *)

SQLITE_API int	sqlite3_total_changes (sqlite3 *)

SQLITE_API void	sqlite3_interrupt (sqlite3 *)

SQLITE_API int	sqlite3_complete (const char *sql)

SQLITE_API int	sqlite3_complete16 (const void *sql)

SQLITE_API int	sqlite3_busy_handler (sqlite3 , int()(void , int), void )

SQLITE_API int	sqlite3_busy_timeout (sqlite3 *, int ms)

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

SQLITE_API void	sqlite3_free_table (char **result)

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

SQLITE_API char *	sqlite3_vmprintf (const char *, va_list)

SQLITE_API char *	sqlite3_snprintf (int, char , const char ,...)

SQLITE_API char *	sqlite3_vsnprintf (int, char , const char , va_list)

SQLITE_API void *	sqlite3_malloc (int)

SQLITE_API void *	sqlite3_malloc64 (sqlite3_uint64)

SQLITE_API void *	sqlite3_realloc (void *, int)

SQLITE_API void *	sqlite3_realloc64 (void *, sqlite3_uint64)

SQLITE_API void	sqlite3_free (void *)

SQLITE_API sqlite3_uint64	sqlite3_msize (void *)

SQLITE_API sqlite3_int64	sqlite3_memory_used (void)

SQLITE_API sqlite3_int64	sqlite3_memory_highwater (int resetFlag)

SQLITE_API void	sqlite3_randomness (int N, void *P)

SQLITE_API int	sqlite3_set_authorizer (sqlite3 , int(xAuth)(void , int, const char , const char , const char , const char ), void pUserData)

SQLITE_API SQLITE_DEPRECATED void *	sqlite3_trace (sqlite3 , void(xTrace)(void , const char ), void *)

SQLITE_API SQLITE_DEPRECATED void *	sqlite3_profile (sqlite3 , void(xProfile)(void , const char , sqlite3_uint64), void *)

SQLITE_API int	sqlite3_trace_v2 (sqlite3 , unsigned uMask, int(xCallback)(unsigned, void , void , void ), void pCtx)

SQLITE_API void	sqlite3_progress_handler (sqlite3 , int, int()(void ), void )

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

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

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

SQLITE_API const char *	sqlite3_uri_parameter (const char zFilename, const char zParam)

SQLITE_API int	sqlite3_uri_boolean (const char zFile, const char zParam, int bDefault)

SQLITE_API sqlite3_int64	sqlite3_uri_int64 (const char , const char , sqlite3_int64)

SQLITE_API const char *	sqlite3_uri_key (const char *zFilename, int N)

SQLITE_API const char *	sqlite3_filename_database (const char *)

SQLITE_API const char *	sqlite3_filename_journal (const char *)

SQLITE_API const char *	sqlite3_filename_wal (const char *)

SQLITE_API sqlite3_file *	sqlite3_database_file_object (const char *)

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

SQLITE_API void	sqlite3_free_filename (char *)

SQLITE_API int	sqlite3_errcode (sqlite3 *db)

SQLITE_API int	sqlite3_extended_errcode (sqlite3 *db)

SQLITE_API const char *	sqlite3_errmsg (sqlite3 *)

SQLITE_API const void *	sqlite3_errmsg16 (sqlite3 *)

SQLITE_API const char *	sqlite3_errstr (int)

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

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

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

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

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

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

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

SQLITE_API const char *	sqlite3_sql (sqlite3_stmt *pStmt)

SQLITE_API char *	sqlite3_expanded_sql (sqlite3_stmt *pStmt)

SQLITE_API const char *	sqlite3_normalized_sql (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_readonly (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_isexplain (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_stmt_busy (sqlite3_stmt *)

SQLITE_API int	sqlite3_bind_blob (sqlite3_stmt , int, const void , int n, void()(void ))

SQLITE_API int	sqlite3_bind_blob64 (sqlite3_stmt , int, const void , sqlite3_uint64, void()(void ))

SQLITE_API int	sqlite3_bind_double (sqlite3_stmt *, int, double)

SQLITE_API int	sqlite3_bind_int (sqlite3_stmt *, int, int)

SQLITE_API int	sqlite3_bind_int64 (sqlite3_stmt *, int, sqlite3_int64)

SQLITE_API int	sqlite3_bind_null (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_bind_text (sqlite3_stmt , int, const char , int, void()(void ))

SQLITE_API int	sqlite3_bind_text16 (sqlite3_stmt , int, const void , int, void()(void ))

SQLITE_API int	sqlite3_bind_text64 (sqlite3_stmt , int, const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API int	sqlite3_bind_value (sqlite3_stmt , int, const sqlite3_value )

SQLITE_API int	sqlite3_bind_pointer (sqlite3_stmt , int, void , const char , void()(void *))

SQLITE_API int	sqlite3_bind_zeroblob (sqlite3_stmt *, int, int n)

SQLITE_API int	sqlite3_bind_zeroblob64 (sqlite3_stmt *, int, sqlite3_uint64)

SQLITE_API int	sqlite3_bind_parameter_count (sqlite3_stmt *)

SQLITE_API const char *	sqlite3_bind_parameter_name (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_bind_parameter_index (sqlite3_stmt , const char zName)

SQLITE_API int	sqlite3_clear_bindings (sqlite3_stmt *)

SQLITE_API int	sqlite3_column_count (sqlite3_stmt *pStmt)

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

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

SQLITE_API const char *	sqlite3_column_database_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_database_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_table_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_table_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_origin_name (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_origin_name16 (sqlite3_stmt *, int)

SQLITE_API const char *	sqlite3_column_decltype (sqlite3_stmt *, int)

SQLITE_API const void *	sqlite3_column_decltype16 (sqlite3_stmt *, int)

SQLITE_API int	sqlite3_step (sqlite3_stmt *)

SQLITE_API int	sqlite3_data_count (sqlite3_stmt *pStmt)

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

SQLITE_API double	sqlite3_column_double (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_int (sqlite3_stmt *, int iCol)

SQLITE_API sqlite3_int64	sqlite3_column_int64 (sqlite3_stmt *, int iCol)

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

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

SQLITE_API sqlite3_value *	sqlite3_column_value (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_bytes (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_bytes16 (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_column_type (sqlite3_stmt *, int iCol)

SQLITE_API int	sqlite3_finalize (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_reset (sqlite3_stmt *pStmt)

SQLITE_API int	sqlite3_create_function (sqlite3 db, const char zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

SQLITE_API int	sqlite3_create_function16 (sqlite3 db, const void zFunctionName, int nArg, int eTextRep, void pApp, void(xFunc)(sqlite3_context , int, sqlite3_value ), void(xStep)(sqlite3_context , int, sqlite3_value ), void(xFinal)(sqlite3_context *))

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

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

SQLITE_API SQLITE_DEPRECATED int	sqlite3_aggregate_count (sqlite3_context *)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_expired (sqlite3_stmt *)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_transfer_bindings (sqlite3_stmt , sqlite3_stmt )

SQLITE_API SQLITE_DEPRECATED int	sqlite3_global_recover (void)

SQLITE_API SQLITE_DEPRECATED void	sqlite3_thread_cleanup (void)

SQLITE_API SQLITE_DEPRECATED int	sqlite3_memory_alarm (void()(void , sqlite3_int64, int), void *, sqlite3_int64)

SQLITE_API const void *	sqlite3_value_blob (sqlite3_value *)

SQLITE_API double	sqlite3_value_double (sqlite3_value *)

SQLITE_API int	sqlite3_value_int (sqlite3_value *)

SQLITE_API sqlite3_int64	sqlite3_value_int64 (sqlite3_value *)

SQLITE_API void *	sqlite3_value_pointer (sqlite3_value , const char )

SQLITE_API const unsigned char *	sqlite3_value_text (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16 (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16le (sqlite3_value *)

SQLITE_API const void *	sqlite3_value_text16be (sqlite3_value *)

SQLITE_API int	sqlite3_value_bytes (sqlite3_value *)

SQLITE_API int	sqlite3_value_bytes16 (sqlite3_value *)

SQLITE_API int	sqlite3_value_type (sqlite3_value *)

SQLITE_API int	sqlite3_value_numeric_type (sqlite3_value *)

SQLITE_API int	sqlite3_value_nochange (sqlite3_value *)

SQLITE_API int	sqlite3_value_frombind (sqlite3_value *)

SQLITE_API unsigned int	sqlite3_value_subtype (sqlite3_value *)

SQLITE_API sqlite3_value *	sqlite3_value_dup (const sqlite3_value *)

SQLITE_API void	sqlite3_value_free (sqlite3_value *)

SQLITE_API void *	sqlite3_aggregate_context (sqlite3_context *, int nBytes)

SQLITE_API void *	sqlite3_user_data (sqlite3_context *)

SQLITE_API sqlite3 *	sqlite3_context_db_handle (sqlite3_context *)

SQLITE_API void *	sqlite3_get_auxdata (sqlite3_context *, int N)

SQLITE_API void	sqlite3_set_auxdata (sqlite3_context , int N, void , void()(void ))

SQLITE_API void	sqlite3_result_blob (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_blob64 (sqlite3_context , const void , sqlite3_uint64, void()(void ))

SQLITE_API void	sqlite3_result_double (sqlite3_context *, double)

SQLITE_API void	sqlite3_result_error (sqlite3_context , const char , int)

SQLITE_API void	sqlite3_result_error16 (sqlite3_context , const void , int)

SQLITE_API void	sqlite3_result_error_toobig (sqlite3_context *)

SQLITE_API void	sqlite3_result_error_nomem (sqlite3_context *)

SQLITE_API void	sqlite3_result_error_code (sqlite3_context *, int)

SQLITE_API void	sqlite3_result_int (sqlite3_context *, int)

SQLITE_API void	sqlite3_result_int64 (sqlite3_context *, sqlite3_int64)

SQLITE_API void	sqlite3_result_null (sqlite3_context *)

SQLITE_API void	sqlite3_result_text (sqlite3_context , const char , int, void()(void ))

SQLITE_API void	sqlite3_result_text64 (sqlite3_context , const char , sqlite3_uint64, void()(void ), unsigned char encoding)

SQLITE_API void	sqlite3_result_text16 (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_text16le (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_text16be (sqlite3_context , const void , int, void()(void ))

SQLITE_API void	sqlite3_result_value (sqlite3_context , sqlite3_value )

SQLITE_API void	sqlite3_result_pointer (sqlite3_context , void , const char , void()(void *))

SQLITE_API void	sqlite3_result_zeroblob (sqlite3_context *, int n)

SQLITE_API int	sqlite3_result_zeroblob64 (sqlite3_context *, sqlite3_uint64 n)

SQLITE_API void	sqlite3_result_subtype (sqlite3_context *, unsigned int)

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

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

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

SQLITE_API int	sqlite3_collation_needed (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const char ))

SQLITE_API int	sqlite3_collation_needed16 (sqlite3 , void , void()(void , sqlite3 , int eTextRep, const void ))

SQLITE_API int	sqlite3_sleep (int)

SQLITE_API int	sqlite3_win32_set_directory (unsigned long type, void *zValue)

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

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

SQLITE_API int	sqlite3_get_autocommit (sqlite3 *)

SQLITE_API sqlite3 *	sqlite3_db_handle (sqlite3_stmt *)

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

SQLITE_API int	sqlite3_db_readonly (sqlite3 db, const char zDbName)

SQLITE_API sqlite3_stmt *	sqlite3_next_stmt (sqlite3 pDb, sqlite3_stmt pStmt)

SQLITE_API void *	sqlite3_commit_hook (sqlite3 , int()(void ), void )

SQLITE_API void *	sqlite3_rollback_hook (sqlite3 , void()(void ), void )

SQLITE_API void *	sqlite3_update_hook (sqlite3 , void()(void , int, char const , char const , sqlite3_int64), void )

SQLITE_API int	sqlite3_enable_shared_cache (int)

SQLITE_API int	sqlite3_release_memory (int)

SQLITE_API int	sqlite3_db_release_memory (sqlite3 *)

SQLITE_API sqlite3_int64	sqlite3_soft_heap_limit64 (sqlite3_int64 N)

SQLITE_API sqlite3_int64	sqlite3_hard_heap_limit64 (sqlite3_int64 N)

SQLITE_API SQLITE_DEPRECATED void	sqlite3_soft_heap_limit (int N)

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

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

SQLITE_API int	sqlite3_enable_load_extension (sqlite3 *db, int onoff)

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

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

SQLITE_API void	sqlite3_reset_auto_extension (void)

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

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

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

SQLITE_API int	sqlite3_declare_vtab (sqlite3 , const char zSQL)

SQLITE_API int	sqlite3_overload_function (sqlite3 , const char zFuncName, int nArg)

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

SQLITE_API int	sqlite3_blob_reopen (sqlite3_blob *, sqlite3_int64)

SQLITE_API int	sqlite3_blob_close (sqlite3_blob *)

SQLITE_API int	sqlite3_blob_bytes (sqlite3_blob *)

SQLITE_API int	sqlite3_blob_read (sqlite3_blob , void Z, int N, int iOffset)

SQLITE_API int	sqlite3_blob_write (sqlite3_blob , const void z, int n, int iOffset)

SQLITE_API sqlite3_vfs *	sqlite3_vfs_find (const char *zVfsName)

SQLITE_API int	sqlite3_vfs_register (sqlite3_vfs *, int makeDflt)

SQLITE_API int	sqlite3_vfs_unregister (sqlite3_vfs *)

SQLITE_API sqlite3_mutex *	sqlite3_mutex_alloc (int)

SQLITE_API void	sqlite3_mutex_free (sqlite3_mutex *)

SQLITE_API void	sqlite3_mutex_enter (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_try (sqlite3_mutex *)

SQLITE_API void	sqlite3_mutex_leave (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_held (sqlite3_mutex *)

SQLITE_API int	sqlite3_mutex_notheld (sqlite3_mutex *)

SQLITE_API sqlite3_mutex *	sqlite3_db_mutex (sqlite3 *)

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

SQLITE_API int	sqlite3_test_control (int op,...)

SQLITE_API int	sqlite3_keyword_count (void)

SQLITE_API int	sqlite3_keyword_name (int, const char *, int )

SQLITE_API int	sqlite3_keyword_check (const char *, int)

SQLITE_API sqlite3_str *	sqlite3_str_new (sqlite3 *)

SQLITE_API char *	sqlite3_str_finish (sqlite3_str *)

SQLITE_API void	sqlite3_str_appendf (sqlite3_str , const char zFormat,...)

SQLITE_API void	sqlite3_str_vappendf (sqlite3_str , const char zFormat, va_list)

SQLITE_API void	sqlite3_str_append (sqlite3_str , const char zIn, int N)

SQLITE_API void	sqlite3_str_appendall (sqlite3_str , const char zIn)

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

SQLITE_API void	sqlite3_str_reset (sqlite3_str *)

SQLITE_API int	sqlite3_str_errcode (sqlite3_str *)

SQLITE_API int	sqlite3_str_length (sqlite3_str *)

SQLITE_API char *	sqlite3_str_value (sqlite3_str *)

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

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

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

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

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

SQLITE_API int	sqlite3_backup_step (sqlite3_backup *p, int nPage)

SQLITE_API int	sqlite3_backup_finish (sqlite3_backup *p)

SQLITE_API int	sqlite3_backup_remaining (sqlite3_backup *p)

SQLITE_API int	sqlite3_backup_pagecount (sqlite3_backup *p)

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

SQLITE_API int	sqlite3_stricmp (const char , const char )

SQLITE_API int	sqlite3_strnicmp (const char , const char , int)

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

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

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

SQLITE_API void *	sqlite3_wal_hook (sqlite3 , int()(void , sqlite3 , const char , int), void )

SQLITE_API int	sqlite3_wal_autocheckpoint (sqlite3 *db, int N)

SQLITE_API int	sqlite3_wal_checkpoint (sqlite3 db, const char zDb)

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

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

SQLITE_API int	sqlite3_vtab_on_conflict (sqlite3 *)

SQLITE_API int	sqlite3_vtab_nochange (sqlite3_context *)

SQLITE_API SQLITE_EXPERIMENTAL const char *	sqlite3_vtab_collation (sqlite3_index_info *, int)

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

SQLITE_API void	sqlite3_stmt_scanstatus_reset (sqlite3_stmt *)

SQLITE_API int	sqlite3_db_cacheflush (sqlite3 *)

SQLITE_API int	sqlite3_system_errno (sqlite3 *)

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

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

SQLITE_API SQLITE_EXPERIMENTAL void	sqlite3_snapshot_free (sqlite3_snapshot *)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_cmp (sqlite3_snapshot p1, sqlite3_snapshot p2)

SQLITE_API SQLITE_EXPERIMENTAL int	sqlite3_snapshot_recover (sqlite3 db, const char zDb)

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

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

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

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

Variables
SQLITE_API SQLITE_EXTERN const char	sqlite3_version []

SQLITE_API SQLITE_EXTERN char *	sqlite3_temp_directory

SQLITE_API SQLITE_EXTERN char *	sqlite3_data_directory

Macro Definition Documentation

◆ _FTS5_H

#define _FTS5_H

Definition at line 11620 of file sqlite3.h.

◆ _SQLITE3RTREE_H_

#define _SQLITE3RTREE_H_

Definition at line 9832 of file sqlite3.h.

◆ FTS5_TOKEN_COLOCATED

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

Definition at line 12124 of file sqlite3.h.

◆ FTS5_TOKENIZE_AUX

#define FTS5_TOKENIZE_AUX 0x0008

Definition at line 12120 of file sqlite3.h.

◆ FTS5_TOKENIZE_DOCUMENT

#define FTS5_TOKENIZE_DOCUMENT 0x0004

Definition at line 12119 of file sqlite3.h.

◆ FTS5_TOKENIZE_PREFIX

#define FTS5_TOKENIZE_PREFIX 0x0002

Definition at line 12118 of file sqlite3.h.

◆ FTS5_TOKENIZE_QUERY

#define FTS5_TOKENIZE_QUERY 0x0001

Definition at line 12117 of file sqlite3.h.

◆ FULLY_WITHIN

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

Definition at line 9926 of file sqlite3.h.

◆ NOT_WITHIN

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

Definition at line 9924 of file sqlite3.h.

◆ PARTLY_WITHIN

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

Definition at line 9925 of file sqlite3.h.

◆ SQLITE3_TEXT

#define SQLITE3_TEXT 3

Definition at line 4752 of file sqlite3.h.

◆ SQLITE_ABORT

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

Definition at line 426 of file sqlite3.h.

◆ SQLITE_ABORT_ROLLBACK

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

Definition at line 527 of file sqlite3.h.

◆ SQLITE_ACCESS_EXISTS

#define SQLITE_ACCESS_EXISTS 0

Definition at line 1428 of file sqlite3.h.

◆ SQLITE_ACCESS_READ

#define SQLITE_ACCESS_READ 2 /* Unused */

Definition at line 1430 of file sqlite3.h.

◆ SQLITE_ACCESS_READWRITE

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

Definition at line 1429 of file sqlite3.h.

◆ SQLITE_ALTER_TABLE

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

Definition at line 3097 of file sqlite3.h.

◆ SQLITE_ANALYZE

#define SQLITE_ANALYZE 28 /* Table Name NULL */

Definition at line 3099 of file sqlite3.h.

◆ SQLITE_ANY

#define SQLITE_ANY 5 /* Deprecated */

Definition at line 5208 of file sqlite3.h.

◆ SQLITE_API

#define SQLITE_API

Definition at line 52 of file sqlite3.h.

◆ SQLITE_APICALL

#define SQLITE_APICALL

Definition at line 58 of file sqlite3.h.

◆ SQLITE_ATTACH

#define SQLITE_ATTACH 24 /* Filename NULL */

Definition at line 3095 of file sqlite3.h.

◆ SQLITE_AUTH

#define SQLITE_AUTH 23 /* Authorization denied */

Definition at line 445 of file sqlite3.h.

◆ SQLITE_AUTH_USER

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

Definition at line 542 of file sqlite3.h.

◆ SQLITE_BLOB

#define SQLITE_BLOB 4

Definition at line 4745 of file sqlite3.h.

◆ SQLITE_BUSY

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

Definition at line 427 of file sqlite3.h.

◆ SQLITE_BUSY_RECOVERY

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

Definition at line 509 of file sqlite3.h.

◆ SQLITE_BUSY_SNAPSHOT

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

Definition at line 510 of file sqlite3.h.

◆ SQLITE_BUSY_TIMEOUT

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

Definition at line 511 of file sqlite3.h.

◆ SQLITE_CALLBACK

#define SQLITE_CALLBACK

Definition at line 64 of file sqlite3.h.

◆ SQLITE_CANTOPEN

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

Definition at line 436 of file sqlite3.h.

◆ SQLITE_CANTOPEN_CONVPATH

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

Definition at line 515 of file sqlite3.h.

◆ SQLITE_CANTOPEN_DIRTYWAL

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

Definition at line 516 of file sqlite3.h.

◆ SQLITE_CANTOPEN_FULLPATH

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

Definition at line 514 of file sqlite3.h.

◆ SQLITE_CANTOPEN_ISDIR

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

Definition at line 513 of file sqlite3.h.

◆ SQLITE_CANTOPEN_NOTEMPDIR

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

Definition at line 512 of file sqlite3.h.

◆ SQLITE_CANTOPEN_SYMLINK

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

Definition at line 517 of file sqlite3.h.

◆ SQLITE_CDECL

#define SQLITE_CDECL

Definition at line 55 of file sqlite3.h.

◆ SQLITE_CHECKPOINT_FULL

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

Definition at line 9089 of file sqlite3.h.

◆ SQLITE_CHECKPOINT_PASSIVE

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

Definition at line 9088 of file sqlite3.h.

◆ SQLITE_CHECKPOINT_RESTART

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

Definition at line 9090 of file sqlite3.h.

◆ SQLITE_CHECKPOINT_TRUNCATE

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

Definition at line 9091 of file sqlite3.h.

◆ SQLITE_CONFIG_COVERING_INDEX_SCAN

#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */

Definition at line 2049 of file sqlite3.h.

◆ SQLITE_CONFIG_GETMALLOC

#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */

Definition at line 2034 of file sqlite3.h.

◆ SQLITE_CONFIG_GETMUTEX

#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */

Definition at line 2040 of file sqlite3.h.

◆ SQLITE_CONFIG_GETPCACHE

#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */

Definition at line 2044 of file sqlite3.h.

◆ SQLITE_CONFIG_GETPCACHE2

#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */

Definition at line 2048 of file sqlite3.h.

◆ SQLITE_CONFIG_HEAP

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

Definition at line 2037 of file sqlite3.h.

◆ SQLITE_CONFIG_LOG

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

Definition at line 2045 of file sqlite3.h.

◆ SQLITE_CONFIG_LOOKASIDE

#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */

Definition at line 2042 of file sqlite3.h.

◆ SQLITE_CONFIG_MALLOC

#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */

Definition at line 2033 of file sqlite3.h.

◆ SQLITE_CONFIG_MEMDB_MAXSIZE

#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */

Definition at line 2058 of file sqlite3.h.

◆ SQLITE_CONFIG_MEMSTATUS

#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */

Definition at line 2038 of file sqlite3.h.

◆ SQLITE_CONFIG_MMAP_SIZE

#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */

Definition at line 2051 of file sqlite3.h.

◆ SQLITE_CONFIG_MULTITHREAD

#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */

Definition at line 2031 of file sqlite3.h.

◆ SQLITE_CONFIG_MUTEX

#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */

Definition at line 2039 of file sqlite3.h.

◆ SQLITE_CONFIG_PAGECACHE

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

Definition at line 2036 of file sqlite3.h.

◆ SQLITE_CONFIG_PCACHE

#define SQLITE_CONFIG_PCACHE 14 /* no-op */

Definition at line 2043 of file sqlite3.h.

◆ SQLITE_CONFIG_PCACHE2

#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */

Definition at line 2047 of file sqlite3.h.

◆ SQLITE_CONFIG_PCACHE_HDRSZ

#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */

Definition at line 2053 of file sqlite3.h.

◆ SQLITE_CONFIG_PMASZ

#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */

Definition at line 2054 of file sqlite3.h.

◆ SQLITE_CONFIG_SCRATCH

#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */

Definition at line 2035 of file sqlite3.h.

◆ SQLITE_CONFIG_SERIALIZED

#define SQLITE_CONFIG_SERIALIZED 3 /* nil */

Definition at line 2032 of file sqlite3.h.

◆ SQLITE_CONFIG_SINGLETHREAD

#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */

Definition at line 2030 of file sqlite3.h.

◆ SQLITE_CONFIG_SMALL_MALLOC

#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */

Definition at line 2056 of file sqlite3.h.

◆ SQLITE_CONFIG_SORTERREF_SIZE

#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */

Definition at line 2057 of file sqlite3.h.

◆ SQLITE_CONFIG_SQLLOG

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

Definition at line 2050 of file sqlite3.h.

◆ SQLITE_CONFIG_STMTJRNL_SPILL

#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */

Definition at line 2055 of file sqlite3.h.

◆ SQLITE_CONFIG_URI

#define SQLITE_CONFIG_URI 17 /* int */

Definition at line 2046 of file sqlite3.h.

◆ SQLITE_CONFIG_WIN32_HEAPSIZE

#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */

Definition at line 2052 of file sqlite3.h.

◆ SQLITE_CONSTRAINT

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

Definition at line 441 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_CHECK

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

Definition at line 528 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_COMMITHOOK

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

Definition at line 529 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_FOREIGNKEY

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

Definition at line 530 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_FUNCTION

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

Definition at line 531 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_NOTNULL

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

Definition at line 532 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_PINNED

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

Definition at line 538 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_PRIMARYKEY

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

Definition at line 533 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_ROWID

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

Definition at line 537 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_TRIGGER

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

Definition at line 534 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_UNIQUE

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

Definition at line 535 of file sqlite3.h.

◆ SQLITE_CONSTRAINT_VTAB

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

Definition at line 536 of file sqlite3.h.

◆ SQLITE_COPY

#define SQLITE_COPY 0 /* No longer used */

Definition at line 3104 of file sqlite3.h.

◆ SQLITE_CORRUPT

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

Definition at line 433 of file sqlite3.h.

◆ SQLITE_CORRUPT_INDEX

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

Definition at line 520 of file sqlite3.h.

◆ SQLITE_CORRUPT_SEQUENCE

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

Definition at line 519 of file sqlite3.h.

◆ SQLITE_CORRUPT_VTAB

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

Definition at line 518 of file sqlite3.h.

◆ SQLITE_CREATE_INDEX

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

Definition at line 3072 of file sqlite3.h.

◆ SQLITE_CREATE_TABLE

#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */

Definition at line 3073 of file sqlite3.h.

◆ SQLITE_CREATE_TEMP_INDEX

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

Definition at line 3074 of file sqlite3.h.

◆ SQLITE_CREATE_TEMP_TABLE

#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */

Definition at line 3075 of file sqlite3.h.

◆ SQLITE_CREATE_TEMP_TRIGGER

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

Definition at line 3076 of file sqlite3.h.

◆ SQLITE_CREATE_TEMP_VIEW

#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */

Definition at line 3077 of file sqlite3.h.

◆ SQLITE_CREATE_TRIGGER

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

Definition at line 3078 of file sqlite3.h.

◆ SQLITE_CREATE_VIEW

#define SQLITE_CREATE_VIEW 8 /* View Name NULL */

Definition at line 3079 of file sqlite3.h.

◆ SQLITE_CREATE_VTABLE

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

Definition at line 3100 of file sqlite3.h.

◆ SQLITE_DBCONFIG_DEFENSIVE

#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */

Definition at line 2339 of file sqlite3.h.

◆ SQLITE_DBCONFIG_DQS_DDL

#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */

Definition at line 2343 of file sqlite3.h.

◆ SQLITE_DBCONFIG_DQS_DML

#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */

Definition at line 2342 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_FKEY

#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */

Definition at line 2331 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER

#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */

Definition at line 2333 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION

#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */

Definition at line 2334 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_QPSG

#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */

Definition at line 2336 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_TRIGGER

#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */

Definition at line 2332 of file sqlite3.h.

◆ SQLITE_DBCONFIG_ENABLE_VIEW

#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */

Definition at line 2344 of file sqlite3.h.

◆ SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */

Definition at line 2341 of file sqlite3.h.

◆ SQLITE_DBCONFIG_LEGACY_FILE_FORMAT

#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */

Definition at line 2345 of file sqlite3.h.

◆ SQLITE_DBCONFIG_LOOKASIDE

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

Definition at line 2330 of file sqlite3.h.

◆ SQLITE_DBCONFIG_MAINDBNAME

#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */

Definition at line 2329 of file sqlite3.h.

◆ SQLITE_DBCONFIG_MAX

#define SQLITE_DBCONFIG_MAX 1017 /* Largest DBCONFIG */

Definition at line 2347 of file sqlite3.h.

◆ SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE

#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */

Definition at line 2335 of file sqlite3.h.

◆ SQLITE_DBCONFIG_RESET_DATABASE

#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */

Definition at line 2338 of file sqlite3.h.

◆ SQLITE_DBCONFIG_TRIGGER_EQP

#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */

Definition at line 2337 of file sqlite3.h.

◆ SQLITE_DBCONFIG_TRUSTED_SCHEMA

#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */

Definition at line 2346 of file sqlite3.h.

◆ SQLITE_DBCONFIG_WRITABLE_SCHEMA

#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */

Definition at line 2340 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_HIT

#define SQLITE_DBSTATUS_CACHE_HIT 7

Definition at line 8156 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_MISS

#define SQLITE_DBSTATUS_CACHE_MISS 8

Definition at line 8157 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_SPILL

#define SQLITE_DBSTATUS_CACHE_SPILL 12

Definition at line 8161 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_USED

#define SQLITE_DBSTATUS_CACHE_USED 1

Definition at line 8150 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_USED_SHARED

#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11

Definition at line 8160 of file sqlite3.h.

◆ SQLITE_DBSTATUS_CACHE_WRITE

#define SQLITE_DBSTATUS_CACHE_WRITE 9

Definition at line 8158 of file sqlite3.h.

◆ SQLITE_DBSTATUS_DEFERRED_FKS

#define SQLITE_DBSTATUS_DEFERRED_FKS 10

Definition at line 8159 of file sqlite3.h.

◆ SQLITE_DBSTATUS_LOOKASIDE_HIT

#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4

Definition at line 8153 of file sqlite3.h.

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6

Definition at line 8155 of file sqlite3.h.

◆ SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE

#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5

Definition at line 8154 of file sqlite3.h.

◆ SQLITE_DBSTATUS_LOOKASIDE_USED

#define SQLITE_DBSTATUS_LOOKASIDE_USED 0

Definition at line 8149 of file sqlite3.h.

◆ SQLITE_DBSTATUS_MAX

#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */

Definition at line 8162 of file sqlite3.h.

◆ SQLITE_DBSTATUS_SCHEMA_USED

#define SQLITE_DBSTATUS_SCHEMA_USED 2

Definition at line 8151 of file sqlite3.h.

◆ SQLITE_DBSTATUS_STMT_USED

#define SQLITE_DBSTATUS_STMT_USED 3

Definition at line 8152 of file sqlite3.h.

◆ SQLITE_DELETE

#define SQLITE_DELETE 9 /* Table Name NULL */

Definition at line 3080 of file sqlite3.h.

◆ SQLITE_DENY

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

Definition at line 3049 of file sqlite3.h.

◆ SQLITE_DEPRECATED

#define SQLITE_DEPRECATED

Definition at line 83 of file sqlite3.h.

◆ SQLITE_DESERIALIZE_FREEONCLOSE

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

Definition at line 9800 of file sqlite3.h.

◆ SQLITE_DESERIALIZE_READONLY

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

Definition at line 9802 of file sqlite3.h.

◆ SQLITE_DESERIALIZE_RESIZEABLE

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

Definition at line 9801 of file sqlite3.h.

◆ SQLITE_DETACH

#define SQLITE_DETACH 25 /* Database Name NULL */

Definition at line 3096 of file sqlite3.h.

◆ SQLITE_DETERMINISTIC

#define SQLITE_DETERMINISTIC 0x000000800

Definition at line 5276 of file sqlite3.h.

◆ SQLITE_DIRECTONLY

#define SQLITE_DIRECTONLY 0x000080000

Definition at line 5277 of file sqlite3.h.

◆ SQLITE_DONE

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

Definition at line 452 of file sqlite3.h.

◆ SQLITE_DROP_INDEX

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

Definition at line 3081 of file sqlite3.h.

◆ SQLITE_DROP_TABLE

#define SQLITE_DROP_TABLE 11 /* Table Name NULL */

Definition at line 3082 of file sqlite3.h.

◆ SQLITE_DROP_TEMP_INDEX

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

Definition at line 3083 of file sqlite3.h.

◆ SQLITE_DROP_TEMP_TABLE

#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */

Definition at line 3084 of file sqlite3.h.

◆ SQLITE_DROP_TEMP_TRIGGER

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

Definition at line 3085 of file sqlite3.h.

◆ SQLITE_DROP_TEMP_VIEW

#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */

Definition at line 3086 of file sqlite3.h.

◆ SQLITE_DROP_TRIGGER

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

Definition at line 3087 of file sqlite3.h.

◆ SQLITE_DROP_VIEW

#define SQLITE_DROP_VIEW 17 /* View Name NULL */

Definition at line 3088 of file sqlite3.h.

◆ SQLITE_DROP_VTABLE

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

Definition at line 3101 of file sqlite3.h.

◆ SQLITE_EMPTY

#define SQLITE_EMPTY 16 /* Internal use only */

Definition at line 438 of file sqlite3.h.

◆ SQLITE_ERROR

#define SQLITE_ERROR 1 /* Generic error */

Definition at line 423 of file sqlite3.h.

◆ SQLITE_ERROR_MISSING_COLLSEQ

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

Definition at line 472 of file sqlite3.h.

◆ SQLITE_ERROR_RETRY

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

Definition at line 473 of file sqlite3.h.

◆ SQLITE_ERROR_SNAPSHOT

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

Definition at line 474 of file sqlite3.h.

◆ SQLITE_EXPERIMENTAL

#define SQLITE_EXPERIMENTAL

Definition at line 84 of file sqlite3.h.

◆ SQLITE_EXTERN

#define SQLITE_EXTERN extern

Definition at line 49 of file sqlite3.h.

◆ SQLITE_FAIL

#define SQLITE_FAIL 3

Definition at line 9239 of file sqlite3.h.

◆ SQLITE_FCNTL_BEGIN_ATOMIC_WRITE

#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31

Definition at line 1160 of file sqlite3.h.

◆ SQLITE_FCNTL_BUSYHANDLER

#define SQLITE_FCNTL_BUSYHANDLER 15

Definition at line 1145 of file sqlite3.h.

◆ SQLITE_FCNTL_CHUNK_SIZE

#define SQLITE_FCNTL_CHUNK_SIZE 6

Definition at line 1136 of file sqlite3.h.

◆ SQLITE_FCNTL_CKPT_DONE

#define SQLITE_FCNTL_CKPT_DONE 37

Definition at line 1166 of file sqlite3.h.

◆ SQLITE_FCNTL_CKPT_START

#define SQLITE_FCNTL_CKPT_START 39

Definition at line 1168 of file sqlite3.h.

◆ SQLITE_FCNTL_COMMIT_ATOMIC_WRITE

#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32

Definition at line 1161 of file sqlite3.h.

◆ SQLITE_FCNTL_COMMIT_PHASETWO

#define SQLITE_FCNTL_COMMIT_PHASETWO 22

Definition at line 1151 of file sqlite3.h.

◆ SQLITE_FCNTL_DATA_VERSION

#define SQLITE_FCNTL_DATA_VERSION 35

Definition at line 1164 of file sqlite3.h.

◆ SQLITE_FCNTL_FILE_POINTER

#define SQLITE_FCNTL_FILE_POINTER 7

Definition at line 1137 of file sqlite3.h.

◆ SQLITE_FCNTL_GET_LOCKPROXYFILE

#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2

Definition at line 1132 of file sqlite3.h.

◆ SQLITE_FCNTL_HAS_MOVED

#define SQLITE_FCNTL_HAS_MOVED 20

Definition at line 1149 of file sqlite3.h.

◆ SQLITE_FCNTL_JOURNAL_POINTER

#define SQLITE_FCNTL_JOURNAL_POINTER 28

Definition at line 1157 of file sqlite3.h.

◆ SQLITE_FCNTL_LAST_ERRNO

#define SQLITE_FCNTL_LAST_ERRNO 4

Definition at line 1134 of file sqlite3.h.

◆ SQLITE_FCNTL_LOCK_TIMEOUT

#define SQLITE_FCNTL_LOCK_TIMEOUT 34

Definition at line 1163 of file sqlite3.h.

◆ SQLITE_FCNTL_LOCKSTATE

#define SQLITE_FCNTL_LOCKSTATE 1

Definition at line 1131 of file sqlite3.h.

◆ SQLITE_FCNTL_MMAP_SIZE

#define SQLITE_FCNTL_MMAP_SIZE 18

Definition at line 1147 of file sqlite3.h.

◆ SQLITE_FCNTL_OVERWRITE

#define SQLITE_FCNTL_OVERWRITE 11

Definition at line 1141 of file sqlite3.h.

◆ SQLITE_FCNTL_PDB

#define SQLITE_FCNTL_PDB 30

Definition at line 1159 of file sqlite3.h.

◆ SQLITE_FCNTL_PERSIST_WAL

#define SQLITE_FCNTL_PERSIST_WAL 10

Definition at line 1140 of file sqlite3.h.

◆ SQLITE_FCNTL_POWERSAFE_OVERWRITE

#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13

Definition at line 1143 of file sqlite3.h.

◆ SQLITE_FCNTL_PRAGMA

#define SQLITE_FCNTL_PRAGMA 14

Definition at line 1144 of file sqlite3.h.

◆ SQLITE_FCNTL_RBU

#define SQLITE_FCNTL_RBU 26

Definition at line 1155 of file sqlite3.h.

◆ SQLITE_FCNTL_RESERVE_BYTES

#define SQLITE_FCNTL_RESERVE_BYTES 38

Definition at line 1167 of file sqlite3.h.

◆ SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE

#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33

Definition at line 1162 of file sqlite3.h.

◆ SQLITE_FCNTL_SET_LOCKPROXYFILE

#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3

Definition at line 1133 of file sqlite3.h.

◆ SQLITE_FCNTL_SIZE_HINT

#define SQLITE_FCNTL_SIZE_HINT 5

Definition at line 1135 of file sqlite3.h.

◆ SQLITE_FCNTL_SIZE_LIMIT

#define SQLITE_FCNTL_SIZE_LIMIT 36

Definition at line 1165 of file sqlite3.h.

◆ SQLITE_FCNTL_SYNC

#define SQLITE_FCNTL_SYNC 21

Definition at line 1150 of file sqlite3.h.

◆ SQLITE_FCNTL_SYNC_OMITTED

#define SQLITE_FCNTL_SYNC_OMITTED 8

Definition at line 1138 of file sqlite3.h.

◆ SQLITE_FCNTL_TEMPFILENAME

#define SQLITE_FCNTL_TEMPFILENAME 16

Definition at line 1146 of file sqlite3.h.

◆ SQLITE_FCNTL_TRACE

#define SQLITE_FCNTL_TRACE 19

Definition at line 1148 of file sqlite3.h.

◆ SQLITE_FCNTL_VFS_POINTER

#define SQLITE_FCNTL_VFS_POINTER 27

Definition at line 1156 of file sqlite3.h.

◆ SQLITE_FCNTL_VFSNAME

#define SQLITE_FCNTL_VFSNAME 12

Definition at line 1142 of file sqlite3.h.

◆ SQLITE_FCNTL_WAL_BLOCK

#define SQLITE_FCNTL_WAL_BLOCK 24

Definition at line 1153 of file sqlite3.h.

◆ SQLITE_FCNTL_WIN32_AV_RETRY

#define SQLITE_FCNTL_WIN32_AV_RETRY 9

Definition at line 1139 of file sqlite3.h.

◆ SQLITE_FCNTL_WIN32_GET_HANDLE

#define SQLITE_FCNTL_WIN32_GET_HANDLE 29

Definition at line 1158 of file sqlite3.h.

◆ SQLITE_FCNTL_WIN32_SET_HANDLE

#define SQLITE_FCNTL_WIN32_SET_HANDLE 23

Definition at line 1152 of file sqlite3.h.

◆ SQLITE_FCNTL_ZIPVFS

#define SQLITE_FCNTL_ZIPVFS 25

Definition at line 1154 of file sqlite3.h.

◆ SQLITE_FLOAT

#define SQLITE_FLOAT 2

Definition at line 4744 of file sqlite3.h.

◆ SQLITE_FORMAT

#define SQLITE_FORMAT 24 /* Not used */

Definition at line 446 of file sqlite3.h.

◆ SQLITE_FULL

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

Definition at line 435 of file sqlite3.h.

◆ SQLITE_FUNCTION

#define SQLITE_FUNCTION 31 /* NULL Function Name */

Definition at line 3102 of file sqlite3.h.

◆ SQLITE_GET_LOCKPROXYFILE

#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE

Definition at line 1171 of file sqlite3.h.

◆ SQLITE_IGNORE

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

Definition at line 3050 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_EQ

#define SQLITE_INDEX_CONSTRAINT_EQ 2

Definition at line 6899 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_FUNCTION

#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150

Definition at line 6913 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_GE

#define SQLITE_INDEX_CONSTRAINT_GE 32

Definition at line 6903 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_GLOB

#define SQLITE_INDEX_CONSTRAINT_GLOB 66

Definition at line 6906 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_GT

#define SQLITE_INDEX_CONSTRAINT_GT 4

Definition at line 6900 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_IS

#define SQLITE_INDEX_CONSTRAINT_IS 72

Definition at line 6912 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_ISNOT

#define SQLITE_INDEX_CONSTRAINT_ISNOT 69

Definition at line 6909 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_ISNOTNULL

#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70

Definition at line 6910 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_ISNULL

#define SQLITE_INDEX_CONSTRAINT_ISNULL 71

Definition at line 6911 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_LE

#define SQLITE_INDEX_CONSTRAINT_LE 8

Definition at line 6901 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_LIKE

#define SQLITE_INDEX_CONSTRAINT_LIKE 65

Definition at line 6905 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_LT

#define SQLITE_INDEX_CONSTRAINT_LT 16

Definition at line 6902 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_MATCH

#define SQLITE_INDEX_CONSTRAINT_MATCH 64

Definition at line 6904 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_NE

#define SQLITE_INDEX_CONSTRAINT_NE 68

Definition at line 6908 of file sqlite3.h.

◆ SQLITE_INDEX_CONSTRAINT_REGEXP

#define SQLITE_INDEX_CONSTRAINT_REGEXP 67

Definition at line 6907 of file sqlite3.h.

◆ SQLITE_INDEX_SCAN_UNIQUE

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

Definition at line 6889 of file sqlite3.h.

◆ SQLITE_INNOCUOUS

#define SQLITE_INNOCUOUS 0x000200000

Definition at line 5279 of file sqlite3.h.

◆ SQLITE_INSERT

#define SQLITE_INSERT 18 /* Table Name NULL */

Definition at line 3089 of file sqlite3.h.

◆ SQLITE_INTEGER

#define SQLITE_INTEGER 1

Definition at line 4743 of file sqlite3.h.

◆ SQLITE_INTERNAL

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

Definition at line 424 of file sqlite3.h.

◆ SQLITE_INTERRUPT

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

Definition at line 431 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC

#define SQLITE_IOCAP_ATOMIC 0x00000001

Definition at line 613 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC16K

#define SQLITE_IOCAP_ATOMIC16K 0x00000040

Definition at line 619 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC1K

#define SQLITE_IOCAP_ATOMIC1K 0x00000004

Definition at line 615 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC2K

#define SQLITE_IOCAP_ATOMIC2K 0x00000008

Definition at line 616 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC32K

#define SQLITE_IOCAP_ATOMIC32K 0x00000080

Definition at line 620 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC4K

#define SQLITE_IOCAP_ATOMIC4K 0x00000010

Definition at line 617 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC512

#define SQLITE_IOCAP_ATOMIC512 0x00000002

Definition at line 614 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC64K

#define SQLITE_IOCAP_ATOMIC64K 0x00000100

Definition at line 621 of file sqlite3.h.

◆ SQLITE_IOCAP_ATOMIC8K

#define SQLITE_IOCAP_ATOMIC8K 0x00000020

Definition at line 618 of file sqlite3.h.

◆ SQLITE_IOCAP_BATCH_ATOMIC

#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000

Definition at line 627 of file sqlite3.h.

◆ SQLITE_IOCAP_IMMUTABLE

#define SQLITE_IOCAP_IMMUTABLE 0x00002000

Definition at line 626 of file sqlite3.h.

◆ SQLITE_IOCAP_POWERSAFE_OVERWRITE

#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000

Definition at line 625 of file sqlite3.h.

◆ SQLITE_IOCAP_SAFE_APPEND

#define SQLITE_IOCAP_SAFE_APPEND 0x00000200

Definition at line 622 of file sqlite3.h.

◆ SQLITE_IOCAP_SEQUENTIAL

#define SQLITE_IOCAP_SEQUENTIAL 0x00000400

Definition at line 623 of file sqlite3.h.

◆ SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN

#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800

Definition at line 624 of file sqlite3.h.

◆ SQLITE_IOERR

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

Definition at line 432 of file sqlite3.h.

◆ SQLITE_IOERR_ACCESS

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

Definition at line 487 of file sqlite3.h.

◆ SQLITE_IOERR_AUTH

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

Definition at line 502 of file sqlite3.h.

◆ SQLITE_IOERR_BEGIN_ATOMIC

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

Definition at line 503 of file sqlite3.h.

◆ SQLITE_IOERR_BLOCKED

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

Definition at line 485 of file sqlite3.h.

◆ SQLITE_IOERR_CHECKRESERVEDLOCK

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

Definition at line 488 of file sqlite3.h.

◆ SQLITE_IOERR_CLOSE

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

Definition at line 490 of file sqlite3.h.

◆ SQLITE_IOERR_COMMIT_ATOMIC

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

Definition at line 504 of file sqlite3.h.

◆ SQLITE_IOERR_CONVPATH

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

Definition at line 500 of file sqlite3.h.

◆ SQLITE_IOERR_DATA

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

Definition at line 506 of file sqlite3.h.

◆ SQLITE_IOERR_DELETE

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

Definition at line 484 of file sqlite3.h.

◆ SQLITE_IOERR_DELETE_NOENT

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

Definition at line 497 of file sqlite3.h.

◆ SQLITE_IOERR_DIR_CLOSE

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

Definition at line 491 of file sqlite3.h.

◆ SQLITE_IOERR_DIR_FSYNC

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

Definition at line 479 of file sqlite3.h.

◆ SQLITE_IOERR_FSTAT

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

Definition at line 481 of file sqlite3.h.

◆ SQLITE_IOERR_FSYNC

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

Definition at line 478 of file sqlite3.h.

◆ SQLITE_IOERR_GETTEMPPATH

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

Definition at line 499 of file sqlite3.h.

◆ SQLITE_IOERR_LOCK

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

Definition at line 489 of file sqlite3.h.

◆ SQLITE_IOERR_MMAP

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

Definition at line 498 of file sqlite3.h.

◆ SQLITE_IOERR_NOMEM

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

Definition at line 486 of file sqlite3.h.

◆ SQLITE_IOERR_RDLOCK

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

Definition at line 483 of file sqlite3.h.

◆ SQLITE_IOERR_READ

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

Definition at line 475 of file sqlite3.h.

◆ SQLITE_IOERR_ROLLBACK_ATOMIC

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

Definition at line 505 of file sqlite3.h.

◆ SQLITE_IOERR_SEEK

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

Definition at line 496 of file sqlite3.h.

◆ SQLITE_IOERR_SHMLOCK

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

Definition at line 494 of file sqlite3.h.

◆ SQLITE_IOERR_SHMMAP

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

Definition at line 495 of file sqlite3.h.

◆ SQLITE_IOERR_SHMOPEN

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

Definition at line 492 of file sqlite3.h.

◆ SQLITE_IOERR_SHMSIZE

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

Definition at line 493 of file sqlite3.h.

◆ SQLITE_IOERR_SHORT_READ

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

Definition at line 476 of file sqlite3.h.

◆ SQLITE_IOERR_TRUNCATE

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

Definition at line 480 of file sqlite3.h.

◆ SQLITE_IOERR_UNLOCK

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

Definition at line 482 of file sqlite3.h.

◆ SQLITE_IOERR_VNODE

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

Definition at line 501 of file sqlite3.h.

◆ SQLITE_IOERR_WRITE

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

Definition at line 477 of file sqlite3.h.

◆ SQLITE_LAST_ERRNO

#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO

Definition at line 1173 of file sqlite3.h.

◆ SQLITE_LIMIT_ATTACHED

#define SQLITE_LIMIT_ATTACHED 7

Definition at line 3903 of file sqlite3.h.

◆ SQLITE_LIMIT_COLUMN

#define SQLITE_LIMIT_COLUMN 2

Definition at line 3898 of file sqlite3.h.

◆ SQLITE_LIMIT_COMPOUND_SELECT

#define SQLITE_LIMIT_COMPOUND_SELECT 4

Definition at line 3900 of file sqlite3.h.

◆ SQLITE_LIMIT_EXPR_DEPTH

#define SQLITE_LIMIT_EXPR_DEPTH 3

Definition at line 3899 of file sqlite3.h.

◆ SQLITE_LIMIT_FUNCTION_ARG

#define SQLITE_LIMIT_FUNCTION_ARG 6

Definition at line 3902 of file sqlite3.h.

◆ SQLITE_LIMIT_LENGTH

#define SQLITE_LIMIT_LENGTH 0

Definition at line 3896 of file sqlite3.h.

◆ SQLITE_LIMIT_LIKE_PATTERN_LENGTH

#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8

Definition at line 3904 of file sqlite3.h.

◆ SQLITE_LIMIT_SQL_LENGTH

#define SQLITE_LIMIT_SQL_LENGTH 1

Definition at line 3897 of file sqlite3.h.

◆ SQLITE_LIMIT_TRIGGER_DEPTH

#define SQLITE_LIMIT_TRIGGER_DEPTH 10

Definition at line 3906 of file sqlite3.h.

◆ SQLITE_LIMIT_VARIABLE_NUMBER

#define SQLITE_LIMIT_VARIABLE_NUMBER 9

Definition at line 3905 of file sqlite3.h.

◆ SQLITE_LIMIT_VDBE_OP

#define SQLITE_LIMIT_VDBE_OP 5

Definition at line 3901 of file sqlite3.h.

◆ SQLITE_LIMIT_WORKER_THREADS

#define SQLITE_LIMIT_WORKER_THREADS 11

Definition at line 3907 of file sqlite3.h.

◆ SQLITE_LOCK_EXCLUSIVE

#define SQLITE_LOCK_EXCLUSIVE 4

Definition at line 640 of file sqlite3.h.

◆ SQLITE_LOCK_NONE

#define SQLITE_LOCK_NONE 0

Definition at line 636 of file sqlite3.h.

◆ SQLITE_LOCK_PENDING

#define SQLITE_LOCK_PENDING 3

Definition at line 639 of file sqlite3.h.

◆ SQLITE_LOCK_RESERVED

#define SQLITE_LOCK_RESERVED 2

Definition at line 638 of file sqlite3.h.

◆ SQLITE_LOCK_SHARED

#define SQLITE_LOCK_SHARED 1

Definition at line 637 of file sqlite3.h.

◆ SQLITE_LOCKED

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

Definition at line 428 of file sqlite3.h.

◆ SQLITE_LOCKED_SHAREDCACHE

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

Definition at line 507 of file sqlite3.h.

◆ SQLITE_LOCKED_VTAB

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

Definition at line 508 of file sqlite3.h.

◆ SQLITE_MISMATCH

#define SQLITE_MISMATCH 20 /* Data type mismatch */

Definition at line 442 of file sqlite3.h.

◆ SQLITE_MISUSE

#define SQLITE_MISUSE 21 /* Library used incorrectly */

Definition at line 443 of file sqlite3.h.

◆ SQLITE_MUTEX_FAST

#define SQLITE_MUTEX_FAST 0

Definition at line 7581 of file sqlite3.h.

◆ SQLITE_MUTEX_RECURSIVE

#define SQLITE_MUTEX_RECURSIVE 1

Definition at line 7582 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_APP1

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

Definition at line 7591 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_APP2

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

Definition at line 7592 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_APP3

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

Definition at line 7593 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_LRU

#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */

Definition at line 7588 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_LRU2

#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */

Definition at line 7589 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_MAIN

#define SQLITE_MUTEX_STATIC_MAIN 2

Definition at line 7583 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_MASTER

#define SQLITE_MUTEX_STATIC_MASTER 2

Definition at line 7599 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_MEM

#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */

Definition at line 7584 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_MEM2

#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */

Definition at line 7585 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_OPEN

#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */

Definition at line 7586 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_PMEM

#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */

Definition at line 7590 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_PRNG

#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */

Definition at line 7587 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_VFS1

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

Definition at line 7594 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_VFS2

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

Definition at line 7595 of file sqlite3.h.

◆ SQLITE_MUTEX_STATIC_VFS3

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

Definition at line 7596 of file sqlite3.h.

◆ SQLITE_NOLFS

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

Definition at line 444 of file sqlite3.h.

◆ SQLITE_NOMEM

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

Definition at line 429 of file sqlite3.h.

◆ SQLITE_NOTADB

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

Definition at line 448 of file sqlite3.h.

◆ SQLITE_NOTFOUND

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

Definition at line 434 of file sqlite3.h.

◆ SQLITE_NOTICE

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

Definition at line 449 of file sqlite3.h.

◆ SQLITE_NOTICE_RECOVER_ROLLBACK

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

Definition at line 540 of file sqlite3.h.

◆ SQLITE_NOTICE_RECOVER_WAL

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

Definition at line 539 of file sqlite3.h.

◆ SQLITE_NULL

#define SQLITE_NULL 5

Definition at line 4746 of file sqlite3.h.

◆ SQLITE_OK

#define SQLITE_OK 0 /* Successful result */

Definition at line 421 of file sqlite3.h.

◆ SQLITE_OK_LOAD_PERMANENTLY

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

Definition at line 543 of file sqlite3.h.

◆ SQLITE_OK_SYMLINK

#define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8))

Definition at line 544 of file sqlite3.h.

◆ SQLITE_OPEN_AUTOPROXY

#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */

Definition at line 558 of file sqlite3.h.

◆ SQLITE_OPEN_CREATE

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

Definition at line 555 of file sqlite3.h.

◆ SQLITE_OPEN_DELETEONCLOSE

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

Definition at line 556 of file sqlite3.h.

◆ SQLITE_OPEN_EXCLUSIVE

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

Definition at line 557 of file sqlite3.h.

◆ SQLITE_OPEN_FULLMUTEX

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

Definition at line 569 of file sqlite3.h.

◆ SQLITE_OPEN_MAIN_DB

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

Definition at line 561 of file sqlite3.h.

◆ SQLITE_OPEN_MAIN_JOURNAL

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

Definition at line 564 of file sqlite3.h.

◆ SQLITE_OPEN_MASTER_JOURNAL

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

Definition at line 577 of file sqlite3.h.

◆ SQLITE_OPEN_MEMORY

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

Definition at line 560 of file sqlite3.h.

◆ SQLITE_OPEN_NOFOLLOW

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

Definition at line 573 of file sqlite3.h.

◆ SQLITE_OPEN_NOMUTEX

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

Definition at line 568 of file sqlite3.h.

◆ SQLITE_OPEN_PRIVATECACHE

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

Definition at line 571 of file sqlite3.h.

◆ SQLITE_OPEN_READONLY

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

Definition at line 553 of file sqlite3.h.

◆ SQLITE_OPEN_READWRITE

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

Definition at line 554 of file sqlite3.h.

◆ SQLITE_OPEN_SHAREDCACHE

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

Definition at line 570 of file sqlite3.h.

◆ SQLITE_OPEN_SUBJOURNAL

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

Definition at line 566 of file sqlite3.h.

◆ SQLITE_OPEN_SUPER_JOURNAL

#define SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */

Definition at line 567 of file sqlite3.h.

◆ SQLITE_OPEN_TEMP_DB

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

Definition at line 562 of file sqlite3.h.

◆ SQLITE_OPEN_TEMP_JOURNAL

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

Definition at line 565 of file sqlite3.h.

◆ SQLITE_OPEN_TRANSIENT_DB

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

Definition at line 563 of file sqlite3.h.

◆ SQLITE_OPEN_URI

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

Definition at line 559 of file sqlite3.h.

◆ SQLITE_OPEN_WAL

#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */

Definition at line 572 of file sqlite3.h.

◆ SQLITE_PERM

#define SQLITE_PERM 3 /* Access permission denied */

Definition at line 425 of file sqlite3.h.

◆ SQLITE_PRAGMA

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

Definition at line 3090 of file sqlite3.h.

◆ SQLITE_PREPARE_NO_VTAB

#define SQLITE_PREPARE_NO_VTAB 0x04

Definition at line 3946 of file sqlite3.h.

◆ SQLITE_PREPARE_NORMALIZE

#define SQLITE_PREPARE_NORMALIZE 0x02

Definition at line 3945 of file sqlite3.h.

◆ SQLITE_PREPARE_PERSISTENT

#define SQLITE_PREPARE_PERSISTENT 0x01

Definition at line 3944 of file sqlite3.h.

◆ SQLITE_PROTOCOL

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

Definition at line 437 of file sqlite3.h.

◆ SQLITE_RANGE

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

Definition at line 447 of file sqlite3.h.

◆ SQLITE_READ

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

Definition at line 3091 of file sqlite3.h.

◆ SQLITE_READONLY

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

Definition at line 430 of file sqlite3.h.

◆ SQLITE_READONLY_CANTINIT

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

Definition at line 525 of file sqlite3.h.

◆ SQLITE_READONLY_CANTLOCK

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

Definition at line 522 of file sqlite3.h.

◆ SQLITE_READONLY_DBMOVED

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

Definition at line 524 of file sqlite3.h.

◆ SQLITE_READONLY_DIRECTORY

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

Definition at line 526 of file sqlite3.h.

◆ SQLITE_READONLY_RECOVERY

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

Definition at line 521 of file sqlite3.h.

◆ SQLITE_READONLY_ROLLBACK

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

Definition at line 523 of file sqlite3.h.

◆ SQLITE_RECURSIVE

#define SQLITE_RECURSIVE 33 /* NULL NULL */

Definition at line 3105 of file sqlite3.h.

◆ SQLITE_REINDEX

#define SQLITE_REINDEX 27 /* Index Name NULL */

Definition at line 3098 of file sqlite3.h.

◆ SQLITE_REPLACE

#define SQLITE_REPLACE 5

Definition at line 9241 of file sqlite3.h.

◆ SQLITE_ROLLBACK

#define SQLITE_ROLLBACK 1

Definition at line 9237 of file sqlite3.h.

◆ SQLITE_ROW

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

Definition at line 451 of file sqlite3.h.

◆ SQLITE_SAVEPOINT

#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */

Definition at line 3103 of file sqlite3.h.

◆ SQLITE_SCANSTAT_EST

#define SQLITE_SCANSTAT_EST 2

Definition at line 9292 of file sqlite3.h.

◆ SQLITE_SCANSTAT_EXPLAIN

#define SQLITE_SCANSTAT_EXPLAIN 4

Definition at line 9294 of file sqlite3.h.

◆ SQLITE_SCANSTAT_NAME

#define SQLITE_SCANSTAT_NAME 3

Definition at line 9293 of file sqlite3.h.

◆ SQLITE_SCANSTAT_NLOOP

#define SQLITE_SCANSTAT_NLOOP 0

Definition at line 9290 of file sqlite3.h.

◆ SQLITE_SCANSTAT_NVISIT

#define SQLITE_SCANSTAT_NVISIT 1

Definition at line 9291 of file sqlite3.h.

◆ SQLITE_SCANSTAT_SELECTID

#define SQLITE_SCANSTAT_SELECTID 5

Definition at line 9295 of file sqlite3.h.

◆ SQLITE_SCHEMA

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

Definition at line 439 of file sqlite3.h.

◆ SQLITE_SELECT

#define SQLITE_SELECT 21 /* NULL NULL */

Definition at line 3092 of file sqlite3.h.

◆ SQLITE_SERIALIZE_NOCOPY

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

Definition at line 9739 of file sqlite3.h.

◆ SQLITE_SET_LOCKPROXYFILE

#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE

Definition at line 1172 of file sqlite3.h.

◆ SQLITE_SHM_EXCLUSIVE

#define SQLITE_SHM_EXCLUSIVE 8

Definition at line 1457 of file sqlite3.h.

◆ SQLITE_SHM_LOCK

#define SQLITE_SHM_LOCK 2

Definition at line 1455 of file sqlite3.h.

◆ SQLITE_SHM_NLOCK

#define SQLITE_SHM_NLOCK 8

Definition at line 1467 of file sqlite3.h.

◆ SQLITE_SHM_SHARED

#define SQLITE_SHM_SHARED 4

Definition at line 1456 of file sqlite3.h.

◆ SQLITE_SHM_UNLOCK

#define SQLITE_SHM_UNLOCK 1

Definition at line 1454 of file sqlite3.h.

◆ SQLITE_SOURCE_ID

#define SQLITE_SOURCE_ID "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f"

Definition at line 128 of file sqlite3.h.

◆ SQLITE_STATIC

#define SQLITE_STATIC ((sqlite3_destructor_type)0)

Definition at line 5622 of file sqlite3.h.

◆ SQLITE_STATUS_MALLOC_COUNT

#define SQLITE_STATUS_MALLOC_COUNT 9

Definition at line 8011 of file sqlite3.h.

◆ SQLITE_STATUS_MALLOC_SIZE

#define SQLITE_STATUS_MALLOC_SIZE 5

Definition at line 8007 of file sqlite3.h.

◆ SQLITE_STATUS_MEMORY_USED

#define SQLITE_STATUS_MEMORY_USED 0

Definition at line 8002 of file sqlite3.h.

◆ SQLITE_STATUS_PAGECACHE_OVERFLOW

#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2

Definition at line 8004 of file sqlite3.h.

◆ SQLITE_STATUS_PAGECACHE_SIZE

#define SQLITE_STATUS_PAGECACHE_SIZE 7

Definition at line 8009 of file sqlite3.h.

◆ SQLITE_STATUS_PAGECACHE_USED

#define SQLITE_STATUS_PAGECACHE_USED 1

Definition at line 8003 of file sqlite3.h.

◆ SQLITE_STATUS_PARSER_STACK

#define SQLITE_STATUS_PARSER_STACK 6

Definition at line 8008 of file sqlite3.h.

◆ SQLITE_STATUS_SCRATCH_OVERFLOW

#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */

Definition at line 8006 of file sqlite3.h.

◆ SQLITE_STATUS_SCRATCH_SIZE

#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */

Definition at line 8010 of file sqlite3.h.

◆ SQLITE_STATUS_SCRATCH_USED

#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */

Definition at line 8005 of file sqlite3.h.

◆ SQLITE_STDCALL

#define SQLITE_STDCALL SQLITE_APICALL

Definition at line 61 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_AUTOINDEX

#define SQLITE_STMTSTATUS_AUTOINDEX 3

Definition at line 8248 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_FULLSCAN_STEP

#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1

Definition at line 8246 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_MEMUSED

#define SQLITE_STMTSTATUS_MEMUSED 99

Definition at line 8252 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_REPREPARE

#define SQLITE_STMTSTATUS_REPREPARE 5

Definition at line 8250 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_RUN

#define SQLITE_STMTSTATUS_RUN 6

Definition at line 8251 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_SORT

#define SQLITE_STMTSTATUS_SORT 2

Definition at line 8247 of file sqlite3.h.

◆ SQLITE_STMTSTATUS_VM_STEP

#define SQLITE_STMTSTATUS_VM_STEP 4

Definition at line 8249 of file sqlite3.h.

◆ SQLITE_SUBTYPE

#define SQLITE_SUBTYPE 0x000100000

Definition at line 5278 of file sqlite3.h.

◆ SQLITE_SYNC_DATAONLY

#define SQLITE_SYNC_DATAONLY 0x00010

Definition at line 670 of file sqlite3.h.

◆ SQLITE_SYNC_FULL

#define SQLITE_SYNC_FULL 0x00003

Definition at line 669 of file sqlite3.h.

◆ SQLITE_SYNC_NORMAL

#define SQLITE_SYNC_NORMAL 0x00002

Definition at line 668 of file sqlite3.h.

◆ SQLITE_SYSAPI

#define SQLITE_SYSAPI

Definition at line 67 of file sqlite3.h.

◆ SQLITE_TESTCTRL_ALWAYS

#define SQLITE_TESTCTRL_ALWAYS 13

Definition at line 7696 of file sqlite3.h.

◆ SQLITE_TESTCTRL_ASSERT

#define SQLITE_TESTCTRL_ASSERT 12

Definition at line 7695 of file sqlite3.h.

◆ SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS

#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10

Definition at line 7693 of file sqlite3.h.

◆ SQLITE_TESTCTRL_BITVEC_TEST

#define SQLITE_TESTCTRL_BITVEC_TEST 8

Definition at line 7691 of file sqlite3.h.

◆ SQLITE_TESTCTRL_BYTEORDER

#define SQLITE_TESTCTRL_BYTEORDER 22

Definition at line 7707 of file sqlite3.h.

◆ SQLITE_TESTCTRL_EXPLAIN_STMT

#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */

Definition at line 7703 of file sqlite3.h.

◆ SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS

#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29

Definition at line 7714 of file sqlite3.h.

◆ SQLITE_TESTCTRL_FAULT_INSTALL

#define SQLITE_TESTCTRL_FAULT_INSTALL 9

Definition at line 7692 of file sqlite3.h.

◆ SQLITE_TESTCTRL_FIRST

#define SQLITE_TESTCTRL_FIRST 5

Definition at line 7687 of file sqlite3.h.

◆ SQLITE_TESTCTRL_IMPOSTER

#define SQLITE_TESTCTRL_IMPOSTER 25

Definition at line 7710 of file sqlite3.h.

◆ SQLITE_TESTCTRL_INTERNAL_FUNCTIONS

#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17

Definition at line 7701 of file sqlite3.h.

◆ SQLITE_TESTCTRL_ISINIT

#define SQLITE_TESTCTRL_ISINIT 23

Definition at line 7708 of file sqlite3.h.

◆ SQLITE_TESTCTRL_ISKEYWORD

#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */

Definition at line 7699 of file sqlite3.h.

◆ SQLITE_TESTCTRL_LAST

#define SQLITE_TESTCTRL_LAST 29 /* Largest TESTCTRL */

Definition at line 7715 of file sqlite3.h.

◆ SQLITE_TESTCTRL_LOCALTIME_FAULT

#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18

Definition at line 7702 of file sqlite3.h.

◆ SQLITE_TESTCTRL_NEVER_CORRUPT

#define SQLITE_TESTCTRL_NEVER_CORRUPT 20

Definition at line 7705 of file sqlite3.h.

◆ SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD

#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19

Definition at line 7704 of file sqlite3.h.

◆ SQLITE_TESTCTRL_OPTIMIZATIONS

#define SQLITE_TESTCTRL_OPTIMIZATIONS 15

Definition at line 7698 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PARSER_COVERAGE

#define SQLITE_TESTCTRL_PARSER_COVERAGE 26

Definition at line 7711 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PENDING_BYTE

#define SQLITE_TESTCTRL_PENDING_BYTE 11

Definition at line 7694 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PRNG_RESET

#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */

Definition at line 7690 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PRNG_RESTORE

#define SQLITE_TESTCTRL_PRNG_RESTORE 6

Definition at line 7689 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PRNG_SAVE

#define SQLITE_TESTCTRL_PRNG_SAVE 5

Definition at line 7688 of file sqlite3.h.

◆ SQLITE_TESTCTRL_PRNG_SEED

#define SQLITE_TESTCTRL_PRNG_SEED 28

Definition at line 7713 of file sqlite3.h.

◆ SQLITE_TESTCTRL_RESERVE

#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */

Definition at line 7697 of file sqlite3.h.

◆ SQLITE_TESTCTRL_RESULT_INTREAL

#define SQLITE_TESTCTRL_RESULT_INTREAL 27

Definition at line 7712 of file sqlite3.h.

◆ SQLITE_TESTCTRL_SCRATCHMALLOC

#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */

Definition at line 7700 of file sqlite3.h.

◆ SQLITE_TESTCTRL_SORTER_MMAP

#define SQLITE_TESTCTRL_SORTER_MMAP 24

Definition at line 7709 of file sqlite3.h.

◆ SQLITE_TESTCTRL_VDBE_COVERAGE

#define SQLITE_TESTCTRL_VDBE_COVERAGE 21

Definition at line 7706 of file sqlite3.h.

◆ SQLITE_TEXT

#define SQLITE_TEXT 3

Definition at line 4750 of file sqlite3.h.

◆ SQLITE_TOOBIG

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

Definition at line 440 of file sqlite3.h.

◆ SQLITE_TRACE_CLOSE

#define SQLITE_TRACE_CLOSE 0x08

Definition at line 3199 of file sqlite3.h.

◆ SQLITE_TRACE_PROFILE

#define SQLITE_TRACE_PROFILE 0x02

Definition at line 3197 of file sqlite3.h.

◆ SQLITE_TRACE_ROW

#define SQLITE_TRACE_ROW 0x04

Definition at line 3198 of file sqlite3.h.

◆ SQLITE_TRACE_STMT

#define SQLITE_TRACE_STMT 0x01

Definition at line 3196 of file sqlite3.h.

◆ SQLITE_TRANSACTION

#define SQLITE_TRANSACTION 22 /* Operation NULL */

Definition at line 3093 of file sqlite3.h.

◆ SQLITE_TRANSIENT

#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)

Definition at line 5623 of file sqlite3.h.

◆ SQLITE_UPDATE

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

Definition at line 3094 of file sqlite3.h.

◆ SQLITE_UTF16

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

Definition at line 5207 of file sqlite3.h.

◆ SQLITE_UTF16_ALIGNED

#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */

Definition at line 5209 of file sqlite3.h.

◆ SQLITE_UTF16BE

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

Definition at line 5206 of file sqlite3.h.

◆ SQLITE_UTF16LE

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

Definition at line 5205 of file sqlite3.h.

◆ SQLITE_UTF8

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

Definition at line 5204 of file sqlite3.h.

◆ SQLITE_VERSION

#define SQLITE_VERSION "3.33.0"

Definition at line 126 of file sqlite3.h.

◆ SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER 3033000

Definition at line 127 of file sqlite3.h.

◆ SQLITE_VTAB_CONSTRAINT_SUPPORT

#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1

Definition at line 9175 of file sqlite3.h.

◆ SQLITE_VTAB_DIRECTONLY

#define SQLITE_VTAB_DIRECTONLY 3

Definition at line 9177 of file sqlite3.h.

◆ SQLITE_VTAB_INNOCUOUS

#define SQLITE_VTAB_INNOCUOUS 2

Definition at line 9176 of file sqlite3.h.

◆ SQLITE_WARNING

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

Definition at line 450 of file sqlite3.h.

◆ SQLITE_WARNING_AUTOINDEX

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

Definition at line 541 of file sqlite3.h.

◆ SQLITE_WIN32_DATA_DIRECTORY_TYPE

#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1

Definition at line 6107 of file sqlite3.h.

◆ SQLITE_WIN32_TEMP_DIRECTORY_TYPE

#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2

Definition at line 6108 of file sqlite3.h.

Typedef Documentation

◆ fts5_api

typedef struct fts5_api fts5_api

Definition at line 12133 of file sqlite3.h.

◆ fts5_extension_function

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

Definition at line 11638 of file sqlite3.h.

◆ fts5_tokenizer

typedef struct fts5_tokenizer fts5_tokenizer

Definition at line 12097 of file sqlite3.h.

◆ Fts5Context

typedef struct Fts5Context Fts5Context

Definition at line 11635 of file sqlite3.h.

◆ Fts5ExtensionApi

typedef struct Fts5ExtensionApi Fts5ExtensionApi

Definition at line 11634 of file sqlite3.h.

◆ Fts5PhraseIter

typedef struct Fts5PhraseIter Fts5PhraseIter

Definition at line 11636 of file sqlite3.h.

◆ Fts5Tokenizer

typedef struct Fts5Tokenizer Fts5Tokenizer

Definition at line 12096 of file sqlite3.h.

◆ sqlite3

typedef struct sqlite3 sqlite3

Definition at line 249 of file sqlite3.h.

◆ sqlite3_api_routines

typedef struct sqlite3_api_routines sqlite3_api_routines

Definition at line 1196 of file sqlite3.h.

◆ sqlite3_backup

typedef struct sqlite3_backup sqlite3_backup

Definition at line 8491 of file sqlite3.h.

◆ sqlite3_blob

typedef struct sqlite3_blob sqlite3_blob

Definition at line 7076 of file sqlite3.h.

◆ sqlite3_callback

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

Definition at line 338 of file sqlite3.h.

◆ sqlite3_context

typedef struct sqlite3_context sqlite3_context

Definition at line 4258 of file sqlite3.h.

◆ sqlite3_destructor_type

typedef void(* sqlite3_destructor_type) (void *)

Definition at line 5621 of file sqlite3.h.

◆ sqlite3_file

typedef struct sqlite3_file sqlite3_file

Definition at line 683 of file sqlite3.h.

◆ sqlite3_index_info

typedef struct sqlite3_index_info sqlite3_index_info

Definition at line 6690 of file sqlite3.h.

◆ sqlite3_int64

typedef sqlite_int64 sqlite3_int64

Definition at line 281 of file sqlite3.h.

◆ sqlite3_io_methods

typedef struct sqlite3_io_methods sqlite3_io_methods

Definition at line 782 of file sqlite3.h.

◆ sqlite3_mem_methods

typedef struct sqlite3_mem_methods sqlite3_mem_methods

Definition at line 1665 of file sqlite3.h.

◆ sqlite3_module

typedef struct sqlite3_module sqlite3_module

Definition at line 6692 of file sqlite3.h.

◆ sqlite3_mutex

typedef struct sqlite3_mutex sqlite3_mutex

Definition at line 1186 of file sqlite3.h.

◆ sqlite3_mutex_methods

typedef struct sqlite3_mutex_methods sqlite3_mutex_methods

Definition at line 7524 of file sqlite3.h.

◆ sqlite3_pcache

typedef struct sqlite3_pcache sqlite3_pcache

Definition at line 8265 of file sqlite3.h.

◆ sqlite3_pcache_methods

typedef struct sqlite3_pcache_methods sqlite3_pcache_methods

Definition at line 8465 of file sqlite3.h.

◆ sqlite3_pcache_methods2

typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2

Definition at line 8442 of file sqlite3.h.

◆ sqlite3_pcache_page

typedef struct sqlite3_pcache_page sqlite3_pcache_page

Definition at line 8277 of file sqlite3.h.

◆ sqlite3_rtree_dbl

typedef double sqlite3_rtree_dbl

Definition at line 9848 of file sqlite3.h.

◆ sqlite3_rtree_geometry

typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry

Definition at line 9839 of file sqlite3.h.

◆ sqlite3_rtree_query_info

typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info

Definition at line 9840 of file sqlite3.h.

◆ sqlite3_snapshot

typedef struct sqlite3_snapshot sqlite3_snapshot

◆ sqlite3_stmt

typedef struct sqlite3_stmt sqlite3_stmt

Definition at line 3796 of file sqlite3.h.

◆ sqlite3_str

typedef struct sqlite3_str sqlite3_str

Definition at line 7784 of file sqlite3.h.

◆ sqlite3_syscall_ptr

typedef void(* sqlite3_syscall_ptr) (void)

Definition at line 1368 of file sqlite3.h.

◆ sqlite3_uint64

typedef sqlite_uint64 sqlite3_uint64

Definition at line 282 of file sqlite3.h.

◆ sqlite3_value

typedef struct sqlite3_value sqlite3_value

Definition at line 4244 of file sqlite3.h.

◆ sqlite3_vfs

typedef struct sqlite3_vfs sqlite3_vfs

Definition at line 1367 of file sqlite3.h.

◆ sqlite3_vtab

typedef struct sqlite3_vtab sqlite3_vtab

Definition at line 6689 of file sqlite3.h.

◆ sqlite3_vtab_cursor

typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor

Definition at line 6691 of file sqlite3.h.

◆ sqlite_int64

typedef long long int sqlite_int64

Definition at line 278 of file sqlite3.h.

◆ sqlite_uint64

typedef unsigned long long int sqlite_uint64

Definition at line 279 of file sqlite3.h.

Function Documentation

◆ sqlite3_aggregate_context()

SQLITE_API void * sqlite3_aggregate_context	(	sqlite3_context *	p,
		int	nBytes )

Definition at line 83867 of file sqlite3.c.

                                                                         {
  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(), testcase, FuncDef::xFinalize, and sqlite3_value::z.

Referenced by countInverse(), db_sql_finalize_function(), db_sql_normal_function(), minmaxStep(), ntileStepFunc(), rankStepFunc(), row_numberValueFunc(), and sumStep().

◆ sqlite3_aggregate_count()

SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count ( sqlite3_context * p )

Definition at line 83969 of file sqlite3.c.

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

Referenced by lcontext_aggregate_count().

◆ sqlite3_auto_extension()

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

Definition at line 124953 of file sqlite3.c.

 {
  int rc = SQLITE_OK;
#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 mutex, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_realloc64(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, SQLITE_NOMEM_BKPT, SQLITE_OK, wsdAutoext, and wsdAutoextInit.

◆ sqlite3_backup_finish()

SQLITE_API int sqlite3_backup_finish ( sqlite3_backup * p )

Definition at line 75625 of file sqlite3.c.

                                                       {
  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

Referenced by cleanupbu(), and sqlite3BtreeCopyFile().

◆ sqlite3_backup_init()

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

Definition at line 75191 of file sqlite3.c.

 {
  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_ERROR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, and SQLITE_OK.

Referenced by lsqlite_backup_init().

◆ sqlite3_backup_pagecount()

SQLITE_API int sqlite3_backup_pagecount ( sqlite3_backup * p )

Definition at line 75693 of file sqlite3.c.

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

Referenced by dbbu_pagecount().

◆ sqlite3_backup_remaining()

SQLITE_API int sqlite3_backup_remaining ( sqlite3_backup * p )

Definition at line 75679 of file sqlite3.c.

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

Referenced by dbbu_remaining().

◆ sqlite3_backup_step()

SQLITE_API int sqlite3_backup_step	(	sqlite3_backup *	p,
		int	nPage )

Definition at line 75371 of file sqlite3.c.

                                                                {
  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 && 0==sqlite3BtreeIsInReadTrans(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 && 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 ){

Referenced by dbbu_step(), and sqlite3BtreeCopyFile().

◆ sqlite3_bind_blob()

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

Definition at line 84390 of file sqlite3.c.

Referenced by dbvm_bind_blob().

◆ sqlite3_bind_blob64()

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

Definition at line 84402 of file sqlite3.c.

 {
#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,
  sqlite3_uint64 nData,
  void (*xDel)(void*)
){
  assert( xDel!=SQLITE_DYNAMIC );

References bindText(), and SQLITE_MISUSE_BKPT.

◆ sqlite3_bind_double()

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

Definition at line 84416 of file sqlite3.c.

                        {
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    return bindText(pStmt, i, zData, (int)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, i);

References invokeValueDestructor().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_int()

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

Definition at line 84426 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
    sqlite3_mutex_leave(p->db->mutex);

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetDouble().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_int64()

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

Definition at line 84429 of file sqlite3.c.

                                                                   {
  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, i);

Referenced by dbvm_bind_index().

◆ sqlite3_bind_null()

SQLITE_API int sqlite3_bind_null	(	sqlite3_stmt *	pStmt,
		int	i )

Definition at line 84439 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetInt64().

Referenced by dbvm_bind_index().

◆ sqlite3_bind_parameter_count()

SQLITE_API int sqlite3_bind_parameter_count ( sqlite3_stmt * pStmt )

Definition at line 84562 of file sqlite3.c.

Referenced by dbvm_bind_names(), dbvm_bind_parameter_count(), dbvm_bind_values(), and dbvm_check_bind_index().

◆ sqlite3_bind_parameter_index()

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

Definition at line 84588 of file sqlite3.c.

84590 {

References nName, Vdbe::pVList, sqlite3VListNameToNum(), and zName.

◆ sqlite3_bind_parameter_name()

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

Definition at line 84573 of file sqlite3.c.

References Vdbe::pVList, and sqlite3VListNumToName().

Referenced by dbvm_bind_names(), and dbvm_bind_parameter_name().

◆ sqlite3_bind_pointer()

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

Definition at line 84448 of file sqlite3.c.

                     {
    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, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);

◆ sqlite3_bind_text()

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

Definition at line 84466 of file sqlite3.c.

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

Referenced by dbvm_bind_index().

◆ sqlite3_bind_text16()

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

Definition at line 84492 of file sqlite3.c.

       {
    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
    return bindText(pStmt, i, zData, (int)nData, xDel, enc);
  }
}
#ifndef SQLITE_OMIT_UTF16
SQLITE_API int sqlite3_bind_text16(
  sqlite3_stmt *pStmt,
  int i,

◆ sqlite3_bind_text64()

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

Definition at line 84475 of file sqlite3.c.

 {
  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 );
  if( nData>0x7fffffff ){

References bindText(), and SQLITE_UTF8.

◆ sqlite3_bind_value()

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

Definition at line 84502 of file sqlite3.c.

 {
  return bindText(pStmt, i, zData, nData, 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: {
      rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
      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.

◆ sqlite3_bind_zeroblob()

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

Definition at line 84533 of file sqlite3.c.

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

◆ sqlite3_bind_zeroblob64()

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

Definition at line 84543 of file sqlite3.c.

                     {
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  sqlite3_mutex_enter(p->db->mutex);
  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
    rc = SQLITE_TOOBIG;
  }else{
    assert( (n & 0x7FFFFFFF)==n );

References Vdbe::aVar, Vdbe::db, sqlite3::mutex, sqlite3_mutex_leave(), and sqlite3VdbeMemSetZeroBlob().

◆ sqlite3_blob_bytes()

SQLITE_API int sqlite3_blob_bytes ( sqlite3_blob * pBlob )

Definition at line 93830 of file sqlite3.c.

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

◆ sqlite3_blob_close()

SQLITE_API int sqlite3_blob_close ( sqlite3_blob * pBlob )

Definition at line 93719 of file sqlite3.c.

                                                      {
  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()

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

Definition at line 93486 of file sqlite3.c.

 {
  int nAttempt = 0;
  int iCol;               /* Index of zColumn in row-record */
  int rc = SQLITE_OK;
  char *zErr = 0;
  Table *pTab;
  Incrblob *pBlob = 0;
  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 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  wrFlag = !!wrFlag;                /* wrFlag = (wrFlag ? 1 : 0); */
 
  sqlite3_mutex_enter(db->mutex);
 
  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
  do {
    memset(&sParse, 0, sizeof(Parse));
    if( !pBlob ) goto blob_open_out;
    sParse.db = db;
    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);
    }
#ifndef SQLITE_OMIT_VIEW
    if( pTab && pTab->pSelect ){
      pTab = 0;
      sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable);
    }
#endif
    if( !pTab ){
      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[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName;
 
    /* Now search pTab for the exact column. */
    for(iCol=0; iCol<pTab->nCol; iCol++) {
      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
        break;
      }
    }
    if( iCol==pTab->nCol ){
      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;
        for(pFKey=pTab->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;
      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      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);
  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
 
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" : 0), zErr);

◆ sqlite3_blob_read()

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

Definition at line 93813 of file sqlite3.c.

◆ sqlite3_blob_reopen()

SQLITE_API int sqlite3_blob_reopen	(	sqlite3_blob *	pBlob,
		sqlite3_int64	iRow )

Definition at line 93845 of file sqlite3.c.

                                                                           {
  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;
    rc = blobSeekToRow(p, iRow, &zErr);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 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_MISUSE_BKPT, SQLITE_OK, and SQLITE_SCHEMA.

◆ sqlite3_blob_write()

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

Definition at line 93820 of file sqlite3.c.

◆ sqlite3_busy_handler()

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

Definition at line 162677 of file sqlite3.c.

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

Referenced by db_busy_handler(), and sqlite3_busy_timeout().

◆ sqlite3_busy_timeout()

SQLITE_API int sqlite3_busy_timeout	(	sqlite3 *	db,
		int	ms )

Definition at line 162731 of file sqlite3.c.

                                                        {
#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);

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

Referenced by db_busy_timeout(), and sqlite3Pragma().

◆ sqlite3_cancel_auto_extension()

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

Definition at line 125000 of file sqlite3.c.

 {
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  int i;
  int n = 0;
  wsdAutoextInit;
  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 mutex, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, wsdAutoext, and wsdAutoextInit.

◆ sqlite3_changes()

SQLITE_API int sqlite3_changes ( sqlite3 * db )

Definition at line 162082 of file sqlite3.c.

                                           {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by changes(), and db_changes().

◆ sqlite3_clear_bindings()

SQLITE_API int sqlite3_clear_bindings ( sqlite3_stmt * pStmt )

Definition at line 83128 of file sqlite3.c.

                                                          {
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->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()

SQLITE_API int sqlite3_close ( sqlite3 * db )

Definition at line 162246 of file sqlite3.c.

Referenced by cleanupdb(), and openDatabase().

◆ sqlite3_close_v2()

SQLITE_API int sqlite3_close_v2 ( sqlite3 * db )

Definition at line 162247 of file sqlite3.c.

References sqlite3Close().

◆ sqlite3_collation_needed()

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

Definition at line 164507 of file sqlite3.c.

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

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

◆ sqlite3_collation_needed16()

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

Definition at line 164528 of file sqlite3.c.

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

References sqlite3::mutex, sqlite3::pCollNeededArg, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3SafetyCheckOk(), SQLITE_MISUSE_BKPT, SQLITE_OK, sqlite3::xCollNeeded, and sqlite3::xCollNeeded16.

◆ sqlite3_column_blob()

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

Definition at line 84091 of file sqlite3.c.

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

Referenced by vm_push_column().

◆ sqlite3_column_bytes()

SQLITE_API int sqlite3_column_bytes	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84101 of file sqlite3.c.

Referenced by vm_push_column().

◆ sqlite3_column_bytes16()

SQLITE_API int sqlite3_column_bytes16	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84106 of file sqlite3.c.

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

◆ sqlite3_column_count()

SQLITE_API int sqlite3_column_count ( sqlite3_stmt * pStmt )

Definition at line 83978 of file sqlite3.c.

Referenced by columnName(), dbvm_columns(), dbvm_get_named_types(), dbvm_get_names(), dbvm_get_types(), dbvm_get_unames(), dbvm_get_utypes(), and sqlite3_exec().

◆ sqlite3_column_database_name()

SQLITE_API const char * sqlite3_column_database_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_database_name16()

SQLITE_API const void * sqlite3_column_database_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_decltype()

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

Definition at line 84241 of file sqlite3.c.

Referenced by dbvm_get_named_types(), dbvm_get_type(), dbvm_get_types(), and dbvm_get_utypes().

◆ sqlite3_column_decltype16()

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

Definition at line 84245 of file sqlite3.c.

84247 {

References COLNAME_DECLTYPE, and columnName().

◆ sqlite3_column_double()

SQLITE_API double sqlite3_column_double	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84111 of file sqlite3.c.

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

Referenced by vm_push_column().

◆ sqlite3_column_int()

SQLITE_API int sqlite3_column_int	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84116 of file sqlite3.c.

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

◆ sqlite3_column_int64()

SQLITE_API sqlite3_int64 sqlite3_column_int64	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84121 of file sqlite3.c.

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

Referenced by vm_push_column().

◆ sqlite3_column_name()

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

Definition at line 84218 of file sqlite3.c.

Referenced by db_do_next_row(), dbvm_get_name(), dbvm_get_named_types(), dbvm_get_named_values(), dbvm_get_names(), dbvm_get_unames(), and sqlite3_exec().

◆ sqlite3_column_name16()

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

Definition at line 84222 of file sqlite3.c.

84224 {

References COLNAME_NAME, and columnName().

◆ sqlite3_column_origin_name()

SQLITE_API const char * sqlite3_column_origin_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_origin_name16()

SQLITE_API const void * sqlite3_column_origin_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_table_name()

SQLITE_API const char * sqlite3_column_table_name	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_table_name16()

SQLITE_API const void * sqlite3_column_table_name16	(	sqlite3_stmt *	,
		int	)

◆ sqlite3_column_text()

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

Definition at line 84126 of file sqlite3.c.

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

Referenced by execSql(), sqlite3_exec(), and vm_push_column().

◆ sqlite3_column_text16()

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

Definition at line 84141 of file sqlite3.c.

◆ sqlite3_column_type()

SQLITE_API int sqlite3_column_type	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84147 of file sqlite3.c.

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

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

Referenced by sqlite3_exec(), and vm_push_column().

◆ sqlite3_column_value()

SQLITE_API sqlite3_value * sqlite3_column_value	(	sqlite3_stmt *	pStmt,
		int	iCol )

Definition at line 84131 of file sqlite3.c.

                                                                               {
  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()

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

Definition at line 163156 of file sqlite3.c.

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

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

Referenced by db_commit_hook().

◆ sqlite3_compileoption_get()

SQLITE_API const char * sqlite3_compileoption_get ( int N )

Definition at line 165586 of file sqlite3.c.

                                                       {
  int nOpt;
  const char **azCompileOpt;

Referenced by sqlite3Pragma().

◆ sqlite3_compileoption_used()

SQLITE_API int sqlite3_compileoption_used ( const char * zOptName )

Definition at line 165553 of file sqlite3.c.

                                                               {
  int i, n;
  int nOpt;
  const char **azCompileOpt;
 
#if 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
     && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0

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

Referenced by compileoptionusedFunc().

◆ sqlite3_complete()

SQLITE_API int sqlite3_complete ( const char * sql )

Definition at line 160710 of file sqlite3.c.

                                                 {
  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 IdChar, sqlite3StrNICmp, SQLITE_MISUSE_BKPT, tkCREATE, tkEND, tkEXPLAIN, tkOTHER, tkSEMI, tkTEMP, tkTRIGGER, and tkWS.

Referenced by lsqlite_complete(), and sqlite3_complete16().

◆ sqlite3_complete16()

SQLITE_API int sqlite3_complete16 ( const void * sql )

Definition at line 160875 of file sqlite3.c.

                                                   {
  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 ){
    rc = sqlite3_complete(zSql8);

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

◆ sqlite3_config()

SQLITE_API int sqlite3_config	(	int	op,
			... )

Definition at line 161425 of file sqlite3.c.

                                          {
  va_list ap;
  int rc = SQLITE_OK;
 
  /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
  ** the SQLite library is in use. */
  if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
 
  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: {
      /* 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*);
      sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
      sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
      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. */
      sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
      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 */
 
#ifdef SQLITE_ENABLE_DESERIALIZE
    case SQLITE_CONFIG_MEMDB_MAXSIZE: {
      sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
      break;
    }
#endif /* SQLITE_ENABLE_DESERIALIZE */
 
    default: {
      rc = SQLITE_ERROR;

References sqlite3GlobalConfig, sqlite3HeaderSizeBtree(), sqlite3HeaderSizePcache(), sqlite3HeaderSizePcache1(), sqlite3MemSetDefault(), sqlite3PCacheSetDefault(), 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_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, and SQLITE_OK.

Referenced by sqlite3MemSetDefault().

◆ sqlite3_context_db_handle()

SQLITE_API sqlite3 * sqlite3_context_db_handle ( sqlite3_context * p )

Definition at line 83794 of file sqlite3.c.

                    : 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

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

Referenced by attachFunc(), changes(), contextMalloc(), detachFunc(), likeFunc(), loadExt(), renameColumnFunc(), renameEditSql(), renameTableFunc(), renameTableTest(), replaceFunc(), statInit(), strftimeFunc(), and substrFunc().

◆ sqlite3_create_collation()

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

Definition at line 164439 of file sqlite3.c.

◆ sqlite3_create_collation16()

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

Definition at line 164477 of file sqlite3.c.

 {
  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 ){
    rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);

◆ sqlite3_create_collation_v2()

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

Definition at line 164452 of file sqlite3.c.

 {
  int rc;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);

Referenced by db_create_collation().

◆ sqlite3_create_filename()

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

Definition at line 165241 of file sqlite3.c.

 {
  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;
  p = appendText(p, zJournal);

References appendText(), and sqlite3_malloc64().

◆ sqlite3_create_function()

SQLITE_API int sqlite3_create_function	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal )

Definition at line 162936 of file sqlite3.c.

Referenced by db_register_function().

◆ sqlite3_create_function16()

SQLITE_API int sqlite3_create_function16	(	sqlite3 *	db,
		const void *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal )

Definition at line 162980 of file sqlite3.c.

 {
  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 );
  zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);

References createFunctionApi().

◆ sqlite3_create_function_v2()

SQLITE_API int sqlite3_create_function_v2	(	sqlite3 *	db,
		const char *	zFunctionName,
		int	nArg,
		int	eTextRep,
		void *	pApp,
		void()(sqlite3_context , int, sqlite3_value **)	xFunc,
		void()(sqlite3_context , int, sqlite3_value **)	xStep,
		void()(sqlite3_context )	xFinal,
		void()(void )	xDestroy )

Definition at line 162949 of file sqlite3.c.

 {
  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 **),
  void (*xStep)(sqlite3_context*,int,sqlite3_value **),

References createFunctionApi().

Referenced by sqlite3_overload_function().

◆ sqlite3_create_module()

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

Definition at line 139679 of file sqlite3.c.

◆ sqlite3_create_module_v2()

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

Definition at line 139694 of file sqlite3.c.

◆ sqlite3_create_window_function()

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

Definition at line 162963 of file sqlite3.c.

 {
  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*),
  void (*xValue)(sqlite3_context*),

References createFunctionApi().

◆ sqlite3_data_count()

SQLITE_API int sqlite3_data_count ( sqlite3_stmt * pStmt )

Definition at line 83987 of file sqlite3.c.

Referenced by db_do_next_row(), and dbvm_step().

◆ sqlite3_database_file_object()

SQLITE_API sqlite3_file * sqlite3_database_file_object ( const char * zName )

Definition at line 56713 of file sqlite3.c.

56719 {

56720 Pager *pPager;

References Pager::fd, and zName.

◆ sqlite3_db_cacheflush()

SQLITE_API int sqlite3_db_cacheflush ( sqlite3 * db )

Definition at line 161881 of file sqlite3.c.

                                                 {
  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 && sqlite3BtreeIsInTrans(pBt) ){
      Pager *pPager = sqlite3BtreePager(pBt);
      rc = sqlite3PagerFlush(pPager);
      if( rc==SQLITE_BUSY ){
        bSeenBusy = 1;
        rc = SQLITE_OK;
      }

◆ sqlite3_db_config()

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

Definition at line 161910 of file sqlite3.c.

                                                     : rc);
}
 
/*
** Configuration settings for an individual database connection
*/
SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
  va_list ap;
  int rc;
  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 */
        u32 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  },
      };
      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;
        }
      }

◆ sqlite3_db_filename()

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

Definition at line 165384 of file sqlite3.c.

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

Referenced by db_db_filename().

◆ sqlite3_db_handle()

SQLITE_API sqlite3 * sqlite3_db_handle ( sqlite3_stmt * pStmt )

Definition at line 84646 of file sqlite3.c.

◆ sqlite3_db_mutex()

SQLITE_API sqlite3_mutex * sqlite3_db_mutex ( sqlite3 * db )

Definition at line 161843 of file sqlite3.c.

                                                       {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

◆ sqlite3_db_readonly()

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

Definition at line 165400 of file sqlite3.c.

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

◆ sqlite3_db_release_memory()

SQLITE_API int sqlite3_db_release_memory ( sqlite3 * db )

Definition at line 161857 of file sqlite3.c.

                                                     {
  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);
      sqlite3PagerShrink(pPager);

Referenced by sqlite3Pragma().

◆ sqlite3_db_status()

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

Definition at line 21515 of file sqlite3.c.

 {
  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 = 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;
      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;
      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;
      for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
        sqlite3VdbeClearObject(db, pVdbe);
        sqlite3DbFree(db, pVdbe);
      }
      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;
      int 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 = nRet;
      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()

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

Definition at line 140366 of file sqlite3.c.

                                                                          {
  VtabCtx *pCtx;
  int rc = SQLITE_OK;
  Table *pTab;
  char *zErr = 0;
  Parse sParse;
 
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pCtx = db->pVtabCtx;
  if( !pCtx || pCtx->bDeclared ){
    sqlite3Error(db, SQLITE_MISUSE);
    sqlite3_mutex_leave(db->mutex);
    return SQLITE_MISUSE_BKPT;
  }
  pTab = pCtx->pTab;
  assert( IsVirtual(pTab) );
 
  memset(&sParse, 0, sizeof(sParse));
  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
  sParse.db = db;
  sParse.nQueryLoop = 1;
  if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable, &zErr)
   && sParse.pNewTable
   && !db->mallocFailed
   && !sParse.pNewTable->pSelect
   && !IsVirtual(sParse.pNewTable)
  ){
    if( !pTab->aCol ){
      Table *pNew = sParse.pNewTable;
      Index *pIdx;
      pTab->aCol = pNew->aCol;
      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, (zErr ? "%s" : 0), zErr);
    sqlite3DbFree(db, zErr);
    rc = SQLITE_ERROR;
  }
  sParse.eParseMode = PARSE_MODE_NORMAL;
 
  if( sParse.pVdbe ){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
  sqlite3ParserReset(&sParse);

References Table::aCol, VtabCtx::bDeclared, Parse::db, Parse::eParseMode, HasRowid, IsVirtual, sqlite3::mallocFailed, sqlite3::mutex, Table::nCol, Parse::nQueryLoop, PARSE_MODE_DECLARE_VTAB, PARSE_MODE_NORMAL, Table::pIndex, VTable::pMod, Module::pModule, Parse::pNewTable, Index::pNext, Table::pSelect, VtabCtx::pTab, Index::pTable, Parse::pVdbe, sqlite3::pVtabCtx, VtabCtx::pVTable, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3DbFree(), sqlite3DeleteTable(), sqlite3Error(), sqlite3ErrorWithMsg(), sqlite3ParserReset(), sqlite3PrimaryKeyIndex(), sqlite3RunParser(), sqlite3SafetyCheckOk(), sqlite3VdbeFinalize(), SQLITE_ERROR, SQLITE_MISUSE, SQLITE_MISUSE_BKPT, SQLITE_OK, Table::tabFlags, TF_NoVisibleRowid, TF_WithoutRowid, and sqlite3_module::xUpdate.

◆ sqlite3_deserialize()

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

◆ sqlite3_drop_modules()

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

Definition at line 139711 of file sqlite3.c.

                                                                      {
  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()

SQLITE_API int sqlite3_enable_load_extension	(	sqlite3 *	db,
		int	onoff )

Definition at line 124907 of file sqlite3.c.

                                                                    {
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;

Referenced by db_load_extension().

◆ sqlite3_enable_shared_cache()

SQLITE_API int sqlite3_enable_shared_cache ( int enable )

Definition at line 64566 of file sqlite3.c.

References sqlite3GlobalConfig, and SQLITE_OK.

◆ sqlite3_errcode()

SQLITE_API int sqlite3_errcode ( sqlite3 * db )

Definition at line 163553 of file sqlite3.c.

                                           {
  if( db && !sqlite3SafetyCheckSickOrOk(db) ){
    return SQLITE_MISUSE_BKPT;

References sqlite3SafetyCheckSickOrOk(), and SQLITE_MISUSE_BKPT.

Referenced by db_errcode(), db_prepare(), dbvm_reset(), lsqlite_do_open(), and openDatabase().

◆ sqlite3_errmsg()

SQLITE_API const char * sqlite3_errmsg ( sqlite3 * db )

Definition at line 163483 of file sqlite3.c.

                                                  {
  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 );
    if( z==0 ){

Referenced by blobSeekToRow(), db_do_next_row(), db_do_rows(), db_errmsg(), execSqlF(), lsqlite_do_open(), sqlite3_exec(), and sqlite3InitCallback().

◆ sqlite3_errmsg16()

SQLITE_API const void * sqlite3_errmsg16 ( sqlite3 * db )

Definition at line 163511 of file sqlite3.c.

                                                    {
  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
    ** sqlite3ApiExit(), to avoid setting the database handle error message.

References sqlite3::errCode, sqlite3::mallocFailed, sqlite3::mutex, sqlite3::pErr, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3_value_text16(), sqlite3ErrorWithMsg(), sqlite3ErrStr(), sqlite3OomClear(), and sqlite3SafetyCheckSickOrOk().

◆ sqlite3_errstr()

SQLITE_API const char * sqlite3_errstr ( int rc )

Definition at line 163580 of file sqlite3.c.

References sqlite3ErrStr().

◆ sqlite3_exec()

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

Definition at line 123455 of file sqlite3.c.

 {
  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_DONE, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_NULL, SQLITE_NullCallback, SQLITE_OK, and SQLITE_ROW.

Referenced by db_exec(), lsqlite_open_ptr(), sqlite3_get_table(), sqlite3AnalysisLoad(), sqlite3InitOne(), and sqlite3VdbeExec().

◆ sqlite3_expanded_sql()

SQLITE_API char * sqlite3_expanded_sql ( sqlite3_stmt * pStmt )

Definition at line 84745 of file sqlite3.c.

                                                          {
#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(), and sqlite3VdbeExpandSql().

◆ sqlite3_expired()

SQLITE_API SQLITE_DEPRECATED int sqlite3_expired ( sqlite3_stmt * pStmt )

Definition at line 83009 of file sqlite3.c.

References Vdbe::expired.

◆ sqlite3_extended_errcode()

SQLITE_API int sqlite3_extended_errcode ( sqlite3 * db )

Definition at line 163562 of file sqlite3.c.

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

◆ sqlite3_extended_result_codes()

SQLITE_API int sqlite3_extended_result_codes	(	sqlite3 *	db,
		int	onoff )

Definition at line 164768 of file sqlite3.c.

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

◆ sqlite3_file_control()

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

Definition at line 164781 of file sqlite3.c.

                                                                                         {
  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{
      rc = sqlite3OsFileControl(fd, op, pArg);

Referenced by sqlite3Pragma(), and sqlite3VdbeExec().

◆ sqlite3_filename_database()

SQLITE_API const char * sqlite3_filename_database ( const char * zFilename )

Definition at line 165350 of file sqlite3.c.

◆ sqlite3_filename_journal()

SQLITE_API const char * sqlite3_filename_journal ( const char * zFilename )

Definition at line 165353 of file sqlite3.c.

                                                                       {
  return databaseName(zFilename);
}
SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){
  zFilename = databaseName(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;

References databaseName().

◆ sqlite3_filename_wal()

SQLITE_API const char * sqlite3_filename_wal ( const char * zFilename )

Definition at line 165362 of file sqlite3.c.

                       {
    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
  return 0;

References sqlite3Strlen30().

◆ sqlite3_finalize()

SQLITE_API int sqlite3_finalize ( sqlite3_stmt * pStmt )

Definition at line 83080 of file sqlite3.c.

                                                    {
  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);

References checkProfileCallback, Vdbe::db, sqlite3::mutex, sqlite3_mutex_enter(), sqlite3ApiExit(), sqlite3LeaveMutexAndCloseZombie(), sqlite3VdbeFinalize(), SQLITE_MISUSE_BKPT, SQLITE_OK, and vdbeSafety().

Referenced by blobSeekToRow(), cleanupvm(), db_close_vm(), db_do_next_row(), and sqlite3InitCallback().

◆ sqlite3_free()

SQLITE_API void sqlite3_free ( void * p )

Definition at line 27692 of file sqlite3.c.

                                     {
  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);

Referenced by attachFunc(), btreeRestoreCursorPosition(), charFunc(), clearAllSharedCacheTableLocks(), closeUnixFile(), createFunctionApi(), db_load_extension(), findInodeInfo(), loadExt(), lsqlite_temp_directory(), openDatabase(), pager_delsuper(), pcache1Destroy(), pcache1ResizeHash(), pthreadMutexFree(), quoteFunc(), rehash(), releaseAllSavepoints(), releaseInodeInfo(), renameColumnParseError(), renameEditSql(), replaceFunc(), saveCursorKey(), setupLookaside(), sqlite3_backup_init(), sqlite3_free_filename(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3_overload_function(), sqlite3AnalysisLoad(), sqlite3AutoLoadExtensions(), sqlite3BitvecBuiltinTest(), sqlite3BtreeIntegrityCheck(), sqlite3BtreeMovetoUnpacked(), sqlite3BtreeOpen(), sqlite3InvalidFunction(), sqlite3LeaveMutexAndCloseZombie(), sqlite3LoadExtension(), sqlite3NotPureFunc(), sqlite3OsInit(), sqlite3PagerClose(), sqlite3PagerOpen(), sqlite3Pragma(), sqlite3RunParser(), sqlite3VdbeExec(), sqlite3VdbeList(), sqlite3VdbeMemGrow(), sqlite3VtabImportErrmsg(), sqlite3WalOpen(), statGet(), unixFullPathname(), unixOpen(), unixOpenSharedMemory(), unixShmPurge(), unixShmUnmap(), vdbePmaWriterFinish(), vdbeSorterListToPMA(), vtabBestIndex(), vtabCallConstructor(), walBeginShmUnreliable(), walIndexRecover(), walIteratorInit(), walRewriteChecksums(), whereLoopAddVirtual(), and whereLoopAddVirtualOne().

◆ sqlite3_free_filename()

SQLITE_API void sqlite3_free_filename ( char * p )

Definition at line 165277 of file sqlite3.c.

References databaseName(), and sqlite3_free().

Referenced by attachFunc(), openDatabase(), and sqlite3ParseUri().

◆ sqlite3_free_table()

SQLITE_API void sqlite3_free_table ( char ** result )

Definition at line 136368 of file sqlite3.c.

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

Referenced by sqlite3_get_table().

◆ sqlite3_get_autocommit()

SQLITE_API int sqlite3_get_autocommit ( sqlite3 * db )

Definition at line 164561 of file sqlite3.c.

                                                  {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

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

◆ sqlite3_get_auxdata()

SQLITE_API void * sqlite3_get_auxdata	(	sqlite3_context *	pCtx,
		int	N )

Definition at line 83888 of file sqlite3.c.

                        :  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;
 
  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, and sqlite3_mutex_held().

◆ sqlite3_get_table()

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

Definition at line 136299 of file sqlite3.c.

 {
  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_INT_TO_PTR, SQLITE_MISUSE_BKPT, SQLITE_NOMEM, SQLITE_NOMEM_BKPT, SQLITE_OK, and TabResult::zErrMsg.

◆ sqlite3_global_recover()

SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover ( void )

Definition at line 164550 of file sqlite3.c.

References SQLITE_OK.

◆ sqlite3_hard_heap_limit64()

SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64 ( sqlite3_int64 N )

Definition at line 27449 of file sqlite3.c.

                                                                   {
  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(), and sqlite3_mutex_leave().

Referenced by sqlite3Pragma().

◆ sqlite3_initialize()

SQLITE_API int sqlite3_initialize ( void )

Definition at line 161196 of file sqlite3.c.

                                       {
  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();
    }
#ifdef SQLITE_ENABLE_DESERIALIZE
    if( rc==SQLITE_OK ){
      rc = sqlite3MemdbInit();
    }
#endif
    if( rc==SQLITE_OK ){
      sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
          sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
      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
  if( bRunExtraInit ){
    int SQLITE_EXTRA_INIT(const char*);

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

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

◆ sqlite3_interrupt()

SQLITE_API void sqlite3_interrupt ( sqlite3 * db )

Definition at line 162748 of file sqlite3.c.

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

Referenced by db_interrupt(), and sqlite3VdbeExec().

◆ sqlite3_keyword_check()

SQLITE_API int sqlite3_keyword_check	(	const char *	zName,
		int	nName )

Definition at line 159878 of file sqlite3.c.

◆ sqlite3_keyword_count()

SQLITE_API int sqlite3_keyword_count ( void )

Definition at line 159877 of file sqlite3.c.

159877{

◆ sqlite3_keyword_name()

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

Definition at line 159871 of file sqlite3.c.

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

References keywordCode(), and TK_ID.

◆ sqlite3_last_insert_rowid()

SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid ( sqlite3 * db )

Definition at line 162054 of file sqlite3.c.

                                                              {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by db_last_insert_rowid(), and dbvm_last_insert_rowid().

◆ sqlite3_libversion()

SQLITE_API const char * sqlite3_libversion ( void )

Definition at line 161104 of file sqlite3.c.

References sqlite3_version.

Referenced by lsqlite_version().

◆ sqlite3_libversion_number()

SQLITE_API int sqlite3_libversion_number ( void )

Definition at line 161117 of file sqlite3.c.

◆ sqlite3_limit()

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

Definition at line 163728 of file sqlite3.c.

                                                                    {
  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] ){

References aHardLimit, sqlite3::aLimit, sqlite3SafetyCheckOk(), 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_MISUSE_BKPT, and SQLITE_N_LIMIT.

Referenced by sqlite3Pragma().

◆ sqlite3_load_extension()

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

Definition at line 124876 of file sqlite3.c.

124887 {

124888 int rc;

Referenced by db_load_extension(), and loadExt().

◆ sqlite3_log()

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

Definition at line 29399 of file sqlite3.c.

29405 {

29406 va_list ap; /* Vararg list */

Referenced by constructAutomaticIndex(), errlogFunc(), logBadConnection(), lookupName(), pager_playback(), robust_open(), sqlite3CorruptError(), sqlite3MemMalloc(), sqlite3MemRealloc(), sqlite3PcacheFetchStress(), sqlite3RunParser(), sqlite3VdbeExec(), unixLogErrorAtLine(), vdbeCommit(), vdbeUnbind(), verifyDbFile(), and walIndexRecover().

◆ sqlite3_malloc()

SQLITE_API void * sqlite3_malloc ( int n )

Definition at line 27615 of file sqlite3.c.

27620 {

Referenced by sqlite3OsInit(), unixFullPathname(), and walRewriteChecksums().

◆ sqlite3_malloc64()

SQLITE_API void * sqlite3_malloc64 ( sqlite3_uint64 n )

Definition at line 27621 of file sqlite3.c.

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

Referenced by charFunc(), findInodeInfo(), sqlite3_create_filename(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3BitvecBuiltinTest(), sqlite3LoadExtension(), sqlite3ParseUri(), unixOpen(), unixOpenSharedMemory(), unixShmMap(), walBeginShmUnreliable(), walIndexRecover(), and walIteratorInit().

◆ sqlite3_memory_alarm()

SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm	(	void()(void , sqlite3_int64, int)	,
		void *	,
		sqlite3_int64	)

◆ sqlite3_memory_highwater()

SQLITE_API sqlite3_int64 sqlite3_memory_highwater ( int resetFlag )

Definition at line 27521 of file sqlite3.c.

References sqlite3_status64(), and SQLITE_STATUS_MEMORY_USED.

◆ sqlite3_memory_used()

SQLITE_API sqlite3_int64 sqlite3_memory_used ( void )

Definition at line 27510 of file sqlite3.c.

◆ sqlite3_mprintf()

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

Definition at line 29323 of file sqlite3.c.

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

Referenced by lsqlite_temp_directory(), renameColumnParseError(), sqlite3_get_table(), sqlite3_get_table_cb(), sqlite3_overload_function(), sqlite3AuthReadCol(), sqlite3InvalidFunction(), sqlite3LoadExtension(), sqlite3NotPureFunc(), sqlite3ParseUri(), sqlite3Pragma(), and unixOpen().

◆ sqlite3_msize()

SQLITE_API sqlite3_uint64 sqlite3_msize ( void * p )

Definition at line 27683 of file sqlite3.c.

◆ sqlite3_mutex_alloc()

SQLITE_API sqlite3_mutex * sqlite3_mutex_alloc ( int id )

Definition at line 25922 of file sqlite3.c.

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

Referenced by findInodeInfo(), and unixOpenSharedMemory().

◆ sqlite3_mutex_enter()

SQLITE_API void sqlite3_mutex_enter ( sqlite3_mutex * p )

Definition at line 25954 of file sqlite3.c.

25959 {

References sqlite3GlobalConfig.

Referenced by backupUpdate(), columnMem(), columnName(), createFunctionApi(), createModule(), findReusableFd(), lockBtreeMutex(), openDatabase(), osLocaltime(), pcache1Alloc(), posixUnlock(), releaseInodeInfo(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_blob_reopen(), sqlite3_cancel_auto_extension(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_declare_vtab(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_expanded_sql(), sqlite3_finalize(), sqlite3_hard_heap_limit64(), sqlite3_initialize(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_reset(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vtab_config(), sqlite3AutoLoadExtensions(), sqlite3BtreeOpen(), sqlite3Malloc(), sqlite3Prepare16(), sqlite3RunParser(), unixCheckReservedLock(), unixLeaveMutex(), unixLock(), unixOpenSharedMemory(), unixShmLock(), unixShmMap(), unixShmUnmap(), and vdbeUnbind().

◆ sqlite3_mutex_free()

SQLITE_API void sqlite3_mutex_free ( sqlite3_mutex * p )

Definition at line 25943 of file sqlite3.c.

25948 {

Referenced by releaseInodeInfo(), removeFromSharingList(), sqlite3_initialize(), sqlite3LeaveMutexAndCloseZombie(), and unixShmPurge().

◆ sqlite3_mutex_held()

SQLITE_API int sqlite3_mutex_held ( sqlite3_mutex * )

◆ sqlite3_mutex_leave()

SQLITE_API void sqlite3_mutex_leave ( sqlite3_mutex * p )

Definition at line 25980 of file sqlite3.c.

25985 {

References sqlite3GlobalConfig.

Referenced by backupUpdate(), columnMallocFailure(), columnName(), createFunctionApi(), createModule(), findReusableFd(), openDatabase(), osLocaltime(), pcache1Alloc(), posixUnlock(), releaseInodeInfo(), removeFromSharingList(), sqlite3_auto_extension(), sqlite3_backup_init(), sqlite3_bind_int(), sqlite3_bind_null(), sqlite3_bind_zeroblob64(), sqlite3_blob_reopen(), sqlite3_cancel_auto_extension(), sqlite3_collation_needed(), sqlite3_collation_needed16(), sqlite3_commit_hook(), sqlite3_declare_vtab(), sqlite3_errmsg16(), sqlite3_exec(), sqlite3_expanded_sql(), sqlite3_hard_heap_limit64(), sqlite3_initialize(), sqlite3_next_stmt(), sqlite3_overload_function(), sqlite3_profile(), sqlite3_progress_handler(), sqlite3_reset(), sqlite3_set_authorizer(), sqlite3_soft_heap_limit64(), sqlite3_step(), sqlite3_table_column_metadata(), sqlite3_trace(), sqlite3_vfs_find(), sqlite3_vfs_register(), sqlite3_vtab_config(), sqlite3AutoLoadExtensions(), sqlite3BtreeOpen(), sqlite3LeaveMutexAndCloseZombie(), sqlite3Malloc(), sqlite3Prepare16(), sqlite3RunParser(), unixCheckReservedLock(), unixLock(), unixOpenSharedMemory(), unixShmLock(), unixShmMap(), unixShmUnmap(), and vdbeUnbind().

◆ sqlite3_mutex_notheld()

SQLITE_API int sqlite3_mutex_notheld ( sqlite3_mutex * )

◆ sqlite3_mutex_try()

SQLITE_API int sqlite3_mutex_try ( sqlite3_mutex * p )

Definition at line 25965 of file sqlite3.c.

                                                  {
  int rc = SQLITE_OK;
  if( p ){

References sqlite3GlobalConfig, and SQLITE_OK.

Referenced by btreeLockCarefully().

◆ sqlite3_next_stmt()

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

Definition at line 84680 of file sqlite3.c.

                                                                             {
  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(), and SQLITE_MISUSE_BKPT.

◆ sqlite3_normalized_sql()

SQLITE_API const char * sqlite3_normalized_sql ( sqlite3_stmt * pStmt )

◆ sqlite3_open()

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

Definition at line 164380 of file sqlite3.c.

◆ sqlite3_open16()

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

Definition at line 164400 of file sqlite3.c.

 {
  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;
    }
  }else{

◆ sqlite3_open_v2()

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

Definition at line 164387 of file sqlite3.c.

 {
  return openDatabase(zFilename, ppDb,
                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
}
SQLITE_API int sqlite3_open_v2(
  const char *filename,   /* Database filename (UTF-8) */

References openDatabase(), SQLITE_OPEN_CREATE, and SQLITE_OPEN_READWRITE.

◆ sqlite3_os_end()

SQLITE_API int sqlite3_os_end ( void )

Definition at line 41473 of file sqlite3.c.

References SQLITE_OK, and unixBigLock.

Referenced by sqlite3_shutdown().

◆ sqlite3_os_init()

SQLITE_API int sqlite3_os_init ( void )

Definition at line 41373 of file sqlite3.c.

                                    {
  /*
  ** 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 */

References ArraySize, aSyscall, sqlite3_vfs_register(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_VFS1, SQLITE_OK, unixBigLock, and UNIXVFS.

Referenced by sqlite3OsInit().

◆ sqlite3_overload_function()

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

Definition at line 163042 of file sqlite3.c.

 {
  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;
  sqlite3_mutex_leave(db->mutex);

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

Referenced by sqlite3RegisterPerConnectionBuiltinFunctions().

◆ sqlite3_prepare()

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

Definition at line 129134 of file sqlite3.c.

◆ sqlite3_prepare16()

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

Definition at line 129250 of file sqlite3.c.

◆ sqlite3_prepare16_v2()

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

Definition at line 129262 of file sqlite3.c.

 {
  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.

◆ sqlite3_prepare16_v3()

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

Definition at line 129274 of file sqlite3.c.

 {
  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.

◆ sqlite3_prepare_v2()

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

Definition at line 129146 of file sqlite3.c.

 {
  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.

Referenced by db_do_rows(), db_prepare(), execSql(), and sqlite3_exec().

◆ sqlite3_prepare_v3()

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

Definition at line 129164 of file sqlite3.c.

 {
  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. */

◆ sqlite3_profile()

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

Definition at line 163126 of file sqlite3.c.

 {
  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;
  db->xProfile = xProfile;

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

◆ sqlite3_progress_handler()

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

Definition at line 162700 of file sqlite3.c.

 {
#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;
  }else{

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

Referenced by db_progress_handler().

◆ sqlite3_randomness()

SQLITE_API void sqlite3_randomness	(	int	N,
		void *	P )

Definition at line 30261 of file sqlite3.c.

                                                     {
  unsigned char t;
  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.isInit = 0;
    sqlite3_mutex_leave(mutex);
    return;
  }
 
  /* Initialize the state of the random number generator once,
  ** the first time this routine is called.  The seed value does
  ** not need to contain a lot of randomness since we are not
  ** trying to do secure encryption or anything like that...
  **
  ** Nothing in this file or anywhere else in SQLite does any kind of
  ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
  ** number generator) not as an encryption device.
  */
  if( !wsdPrng.isInit ){
    int i;
    char k[256];
    wsdPrng.j = 0;
    wsdPrng.i = 0;
    sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
    for(i=0; i<256; i++){
      wsdPrng.s[i] = (u8)i;
    }
    for(i=0; i<256; i++){
      wsdPrng.j += wsdPrng.s[i] + k[i];
      t = wsdPrng.s[wsdPrng.j];
      wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
      wsdPrng.s[i] = t;
    }
    wsdPrng.isInit = 1;
  }
 
  assert( N>0 );
  do{
    wsdPrng.i++;
    t = wsdPrng.s[wsdPrng.i];
    wsdPrng.j += t;
    wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];

Referenced by randomFunc(), sqlite3BitvecBuiltinTest(), sqlite3ColumnsFromExprList(), sqlite3VdbeExec(), unixGetTempname(), unixOpen(), vdbeCommit(), walCheckpoint(), walRestartLog(), and writeJournalHdr().

◆ sqlite3_realloc()

SQLITE_API void * sqlite3_realloc	(	void *	pOld,
		int	n )

Definition at line 27819 of file sqlite3.c.

27824 {

27825#ifndef SQLITE_OMIT_AUTOINIT

Referenced by unixShmMap().

◆ sqlite3_realloc64()

SQLITE_API void * sqlite3_realloc64	(	void *	pOld,
		sqlite3_uint64	n )

Definition at line 27826 of file sqlite3.c.

27831 {

Referenced by sqlite3_auto_extension().

◆ sqlite3_release_memory()

SQLITE_API int sqlite3_release_memory ( int n )

Definition at line 27335 of file sqlite3.c.

                                            {
#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 UNUSED_PARAMETER.

◆ sqlite3_reset()

SQLITE_API int sqlite3_reset ( sqlite3_stmt * pStmt )

Definition at line 83107 of file sqlite3.c.

                                                 {
  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(), and SQLITE_OK.

Referenced by db_do_next_row(), dbvm_reset(), sqlite3_step(), and sqlite3Step().

◆ sqlite3_reset_auto_extension()

SQLITE_API void sqlite3_reset_auto_extension ( void )

Definition at line 125025 of file sqlite3.c.

                                                  {
#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().

◆ sqlite3_result_blob()

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

Definition at line 83379 of file sqlite3.c.

       {
    xDel((void*)p);
  }
  if( pCtx ) sqlite3_result_error_toobig(pCtx);
  return SQLITE_TOOBIG;
}
SQLITE_API void sqlite3_result_blob(
  sqlite3_context *pCtx,
  const void *z,
  int n,

Referenced by lcontext_result_blob(), and statGet().

◆ sqlite3_result_blob64()

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

Definition at line 83389 of file sqlite3.c.

 {
  assert( n>=0 );
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, 0, xDel);
}
SQLITE_API void sqlite3_result_blob64(
  sqlite3_context *pCtx,
  const void *z,
  sqlite3_uint64 n,
  void (*xDel)(void *)
){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );

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

Referenced by substrFunc().

◆ sqlite3_result_double()

SQLITE_API void sqlite3_result_double	(	sqlite3_context *	pCtx,
		double	rVal )

Definition at line 83403 of file sqlite3.c.

                    {
    (void)invokeValueDestructor(z, xDel, pCtx);
  }else{
    setResultStrOrError(pCtx, z, (int)n, 0, xDel);

References invokeValueDestructor().

Referenced by absFunc(), juliandayFunc(), lcontext_result(), and lcontext_result_double().

◆ sqlite3_result_error()

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

Definition at line 83407 of file sqlite3.c.

                                                                         {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);

Referenced by absFunc(), attachFunc(), db_sql_finalize_function(), db_sql_normal_function(), detachFunc(), lcontext_result_error(), likeFunc(), loadExt(), localtimeOffset(), ntileStepFunc(), renameColumnParseError(), sqlite3InvalidFunction(), and sqlite3NotPureFunc().

◆ sqlite3_result_error16()

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

Definition at line 83413 of file sqlite3.c.

                                                                                 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}

References sqlite3_value::db, sqlite3_context::isError, sqlite3::mutex, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3VdbeMemSetStr(), SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF8.

◆ sqlite3_result_error_code()

SQLITE_API void sqlite3_result_error_code	(	sqlite3_context *	pCtx,
		int	errCode )

Definition at line 83520 of file sqlite3.c.

                                                    {
    return SQLITE_TOOBIG;
  }
  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
  return SQLITE_OK;
}
SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
  pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
  if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;

References SQLITE_TOOBIG.

Referenced by attachFunc(), renameColumnFunc(), and renameTableFunc().

◆ sqlite3_result_error_nomem()

SQLITE_API void sqlite3_result_error_nomem ( sqlite3_context * pCtx )

Definition at line 83540 of file sqlite3.c.

Referenced by charFunc(), contextMalloc(), instrFunc(), replaceFunc(), statGet(), statInit(), and strftimeFunc().

◆ sqlite3_result_error_toobig()

SQLITE_API void sqlite3_result_error_toobig ( sqlite3_context * pCtx )

Definition at line 83532 of file sqlite3.c.

Referenced by contextMalloc(), invokeValueDestructor(), replaceFunc(), and strftimeFunc().

◆ sqlite3_result_int()

SQLITE_API void sqlite3_result_int	(	sqlite3_context *	pCtx,
		int	iVal )

Definition at line 83419 of file sqlite3.c.

                                                                                   {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

References sqlite3_value::db, sqlite3_context::isError, sqlite3::mutex, sqlite3_context::pOut, sqlite3_mutex_held(), sqlite3VdbeMemSetStr(), SQLITE_ERROR, SQLITE_TRANSIENT, and SQLITE_UTF16NATIVE.

Referenced by changes(), compileoptionusedFunc(), instrFunc(), lcontext_result_int(), likeFunc(), and renameTableTest().

◆ sqlite3_result_int64()

SQLITE_API void sqlite3_result_int64	(	sqlite3_context *	pCtx,
		sqlite3_int64	iVal )

Definition at line 83423 of file sqlite3.c.

83425 {

83426 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

Referenced by absFunc(), countInverse(), lcontext_result(), randomFunc(), and statGet().

◆ sqlite3_result_null()

SQLITE_API void sqlite3_result_null ( sqlite3_context * pCtx )

Definition at line 83427 of file sqlite3.c.

83429 {

83430 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

Referenced by absFunc(), lcontext_result(), and lcontext_result_null().

◆ sqlite3_result_pointer()

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

Definition at line 83431 of file sqlite3.c.

                                                          {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetNull(pCtx->pOut);
}
SQLITE_API void sqlite3_result_pointer(
  sqlite3_context *pCtx,
  void *pPtr,
  const char *zPType,
  void (*xDestructor)(void*)
){

◆ sqlite3_result_subtype()

SQLITE_API void sqlite3_result_subtype	(	sqlite3_context *	pCtx,
		unsigned int	eSubtype )

Definition at line 83443 of file sqlite3.c.

◆ sqlite3_result_text()

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

Definition at line 83449 of file sqlite3.c.

                                                                                    {
  Mem *pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );
  pOut->eSubtype = eSubtype & 0xff;
  pOut->flags |= MEM_Subtype;
}
SQLITE_API void sqlite3_result_text(
  sqlite3_context *pCtx,
  const char *z,

References sqlite3_value::db, sqlite3_value::eSubtype, sqlite3_value::flags, MEM_Subtype, sqlite3::mutex, sqlite3_context::pOut, and sqlite3_mutex_held().

Referenced by dateFunc(), datetimeFunc(), lcontext_result(), lcontext_result_text(), quoteFunc(), renameEditSql(), replaceFunc(), sourceidFunc(), statGet(), strftimeFunc(), and timeFunc().

◆ sqlite3_result_text16()

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

Definition at line 83475 of file sqlite3.c.

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

◆ sqlite3_result_text16be()

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

Definition at line 83484 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, 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.

◆ sqlite3_result_text16le()

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

Definition at line 83493 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, 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.

◆ sqlite3_result_text64()

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

Definition at line 83458 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
}
SQLITE_API void sqlite3_result_text64(
  sqlite3_context *pCtx,
  const char *z,
  sqlite3_uint64 n,
  void (*xDel)(void *),
  unsigned char enc
){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );
  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

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

Referenced by charFunc(), and substrFunc().

◆ sqlite3_result_value()

SQLITE_API void sqlite3_result_value	(	sqlite3_context *	pCtx,
		sqlite3_value *	pValue )

Definition at line 83503 of file sqlite3.c.

 {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);

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

Referenced by last_valueFinalizeFunc(), nullifFunc(), quoteFunc(), and replaceFunc().

◆ sqlite3_result_zeroblob()

SQLITE_API void sqlite3_result_zeroblob	(	sqlite3_context *	pCtx,
		int	n )

Definition at line 83507 of file sqlite3.c.

83509 {

83510 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

◆ sqlite3_result_zeroblob64()

SQLITE_API int sqlite3_result_zeroblob64	(	sqlite3_context *	pCtx,
		sqlite3_uint64	n )

Definition at line 83511 of file sqlite3.c.

                                                                     {
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
}
SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
  Mem *pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );

◆ sqlite3_rollback_hook()

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

Definition at line 163206 of file sqlite3.c.

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

Referenced by db_rollback_hook().

◆ sqlite3_rtree_geometry_callback()

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

◆ sqlite3_rtree_query_callback()

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

◆ sqlite3_serialize()

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

◆ sqlite3_set_authorizer()

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

Definition at line 110182 of file sqlite3.c.

 {
#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_MISUSE_BKPT, SQLITE_OK, and sqlite3::xAuth.

◆ sqlite3_set_auxdata()

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

Definition at line 83916 of file sqlite3.c.

                        :  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 = 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(), and AuxData::xDeleteAux.

◆ sqlite3_set_last_insert_rowid()

SQLITE_API void sqlite3_set_last_insert_rowid	(	sqlite3 *	db,
		sqlite3_int64	iRowid )

Definition at line 162067 of file sqlite3.c.

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

◆ sqlite3_shutdown()

SQLITE_API int sqlite3_shutdown ( void )

Definition at line 161371 of file sqlite3.c.

                                     {
#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
  }
  if( sqlite3GlobalConfig.isMutexInit ){

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

◆ sqlite3_sleep()

SQLITE_API int sqlite3_sleep ( int ms )

Definition at line 164752 of file sqlite3.c.

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

◆ sqlite3_snapshot_cmp()

SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp	(	sqlite3_snapshot *	p1,
		sqlite3_snapshot *	p2 )

◆ sqlite3_snapshot_free()

SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free ( sqlite3_snapshot * )

◆ sqlite3_snapshot_get()

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

◆ sqlite3_snapshot_open()

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

◆ sqlite3_snapshot_recover()

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

◆ sqlite3_snprintf()

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

Definition at line 29363 of file sqlite3.c.

29369 {

29370 char *z;

Referenced by createTableStmt(), dateFunc(), datetimeFunc(), detachFunc(), openDirectory(), quoteFunc(), sqlite3LoadExtension(), sqlite3VdbeReset(), statGet(), strftimeFunc(), timeFunc(), unixGetTempname(), unixOpenSharedMemory(), and vdbeCommit().

◆ sqlite3_soft_heap_limit()

SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit ( int N )

Definition at line 27432 of file sqlite3.c.

◆ sqlite3_soft_heap_limit64()

SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64 ( sqlite3_int64 N )

Definition at line 27407 of file sqlite3.c.

                                                                   {
  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(), and SQLITE_STATUS_MEMORY_USED.

Referenced by sqlite3Pragma().

◆ sqlite3_sourceid()

SQLITE_API const char * sqlite3_sourceid ( void )

Definition at line 230510 of file sqlite3.c.

References SQLITE_SOURCE_ID.

Referenced by sourceidFunc(), and sqlite3CorruptError().

◆ sqlite3_sql()

SQLITE_API const char * sqlite3_sql ( sqlite3_stmt * pStmt )

Definition at line 84731 of file sqlite3.c.

Referenced by sqlite3_expanded_sql(), and sqlite3Reprepare().

◆ sqlite3_status()

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

Definition at line 21472 of file sqlite3.c.

                                                                                    {
  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()

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

Definition at line 21447 of file sqlite3.c.

 {
  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];

Referenced by sqlite3_memory_highwater().

◆ sqlite3_step()

SQLITE_API int sqlite3_step ( sqlite3_stmt * pStmt )

Definition at line 83730 of file sqlite3.c.

                                                {
  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);
  v->doingRerun = 0;
  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);

References Vdbe::db, Vdbe::doingRerun, Vdbe::expired, sqlite3::mallocFailed, 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_MAX_SCHEMA_RETRY, SQLITE_MISUSE_BKPT, SQLITE_NOMEM_BKPT, SQLITE_OK, SQLITE_SCHEMA, vdbeSafetyNotNull(), and Vdbe::zErrMsg.

Referenced by blobSeekToRow(), execSql(), sqlite3_exec(), and stepvm().

◆ sqlite3_stmt_busy()

SQLITE_API int sqlite3_stmt_busy ( sqlite3_stmt * pStmt )

Definition at line 84669 of file sqlite3.c.

◆ sqlite3_stmt_isexplain()

SQLITE_API int sqlite3_stmt_isexplain ( sqlite3_stmt * pStmt )

Definition at line 84662 of file sqlite3.c.

◆ sqlite3_stmt_readonly()

SQLITE_API int sqlite3_stmt_readonly ( sqlite3_stmt * pStmt )

Definition at line 84654 of file sqlite3.c.

◆ sqlite3_stmt_scanstatus()

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

◆ sqlite3_stmt_scanstatus_reset()

SQLITE_API void sqlite3_stmt_scanstatus_reset ( sqlite3_stmt * )

◆ sqlite3_stmt_status()

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

Definition at line 84701 of file sqlite3.c.

                                                                              {
  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;
    sqlite3VdbeClearObject(db, pVdbe);
    sqlite3DbFree(db, pVdbe);
    db->pnBytesFreed = 0;
    sqlite3_mutex_leave(db->mutex);

◆ sqlite3_str_append()

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

Definition at line 29123 of file sqlite3.c.

                                                                        {
  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);

Referenced by explainAppendTerm(), explainIndexRange(), sqlite3_str_vappendf(), sqlite3RunParser(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), and sqlite3WhereExplainOneScan().

◆ sqlite3_str_appendall()

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

Definition at line 29140 of file sqlite3.c.

Referenced by explainAppendTerm(), sqlite3_str_vappendf(), sqlite3VdbeDisplayP4(), and sqlite3WhereExplainOneScan().

◆ sqlite3_str_appendchar()

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

Definition at line 29095 of file sqlite3.c.

29101 {

Referenced by sqlite3_str_vappendf().

◆ sqlite3_str_appendf()

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

Definition at line 29440 of file sqlite3.c.

References sqlite3_str_vappendf().

Referenced by explainIndexRange(), sqlite3RunParser(), sqlite3VdbeDisplayP4(), sqlite3VdbeExpandSql(), sqlite3WhereExplainOneScan(), and vdbeMemRenderNum().

◆ sqlite3_str_errcode()

SQLITE_API int sqlite3_str_errcode ( sqlite3_str * p )

Definition at line 29197 of file sqlite3.c.

◆ sqlite3_str_finish()

SQLITE_API char * sqlite3_str_finish ( sqlite3_str * p )

Definition at line 29185 of file sqlite3.c.

                                   {
   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 SQLITE_NOMEM.

Referenced by sqlite3RunParser().

◆ sqlite3_str_length()

SQLITE_API int sqlite3_str_length ( sqlite3_str * p )

Definition at line 29202 of file sqlite3.c.

29203 {

29204 return p ? p->accError : SQLITE_NOMEM;

References sqlite3_str::accError, and SQLITE_NOMEM.

◆ sqlite3_str_new()

SQLITE_API sqlite3_str * sqlite3_str_new ( sqlite3 * db )

Definition at line 29251 of file sqlite3.c.

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

Referenced by sqlite3RunParser().

◆ sqlite3_str_reset()

SQLITE_API void sqlite3_str_reset ( sqlite3_str * p )

Definition at line 29216 of file sqlite3.c.

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

Referenced by sqlite3BtreeIntegrityCheck(), sqlite3StrAccumEnlarge(), and sqlite3VdbeExpandSql().

◆ sqlite3_str_value()

SQLITE_API char * sqlite3_str_value ( sqlite3_str * p )

Definition at line 29207 of file sqlite3.c.

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

References sqlite3_str::nChar.

◆ sqlite3_str_vappendf()

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

Definition at line 28341 of file sqlite3.c.

 {
  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 */
  LONGDOUBLE_TYPE 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 */
#ifndef SQLITE_OMIT_FLOATING_POINT
  int  exp, e2;              /* exponent of real numbers */
  int nsd;                   /* Number of significant digits returned */
  double rounder;            /* Used for rounding floating point values */
  etByte flag_dp;            /* True if decimal point should be shown */
  etByte flag_rtz;           /* True if trailing zeros should be removed */
#endif
  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 ){
            if( v==SMALLEST_INT64 ){
              longvalue = ((u64)1)<<63;
            }else{
              longvalue = -v;
            }
            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:
        if( bArgList ){
          realvalue = getDoubleArg(pArgList);
        }else{
          realvalue = va_arg(ap,double);
        }
#ifdef SQLITE_OMIT_FLOATING_POINT
        length = 0;
#else
        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( realvalue<0.0 ){
          realvalue = -realvalue;
          prefix = '-';
        }else{
          prefix = flag_prefix;
        }
        if( xtype==etGENERIC && precision>0 ) precision--;
        testcase( precision>0xfff );
        idx = precision & 0xfff;
        rounder = arRound[idx%10];
        while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; }
        if( xtype==etFLOAT ){
          double rx = (double)realvalue;
          sqlite3_uint64 u;
          int ex;
          memcpy(&u, &rx, sizeof(u));
          ex = -1023 + (int)((u>>52)&0x7ff);
          if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16;
          realvalue += rounder;
        }
        /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
        exp = 0;
        if( sqlite3IsNaN((double)realvalue) ){
          bufpt = "NaN";
          length = 3;
          break;
        }
        if( realvalue>0.0 ){
          LONGDOUBLE_TYPE scale = 1.0;
          while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;}
          while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; }
          while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; }
          realvalue /= scale;
          while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
          while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
          if( exp>350 ){
            bufpt = buf;
            buf[0] = prefix;
            memcpy(buf+(prefix!=0),"Inf",4);
            length = 3+(prefix!=0);
            break;
          }
        }
        bufpt = buf;
        /*
        ** If the field type is etGENERIC, then convert to either etEXP
        ** or etFLOAT, as appropriate.
        */
        if( xtype!=etFLOAT ){
          realvalue += rounder;
          if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
        }
        if( xtype==etGENERIC ){
          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 = exp;
        }
        {
          i64 szBufNeeded;           /* Size of a temporary buffer needed */
          szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15;
          if( szBufNeeded > etBUFSIZE ){
            bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded);
            if( bufpt==0 ) return;
          }
        }
        zOut = bufpt;
        nsd = 16 + flag_altform2*10;
        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 */
        if( e2<0 ){
          *(bufpt++) = '0';
        }else{
          for(; e2>=0; e2--){
            *(bufpt++) = et_getdigit(&realvalue,&nsd);
          }
        }
        /* 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--, e2++){
          assert( precision>0 );
          *(bufpt++) = '0';
        }
        /* Significant digits after the decimal point */
        while( (precision--)>0 ){
          *(bufpt++) = et_getdigit(&realvalue,&nsd);
        }
        /* 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 ){
          *(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;
        }
#endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
        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);
          if( ch<0x00080 ){
            buf[0] = ch & 0xff;
            length = 1;
          }else if( ch<0x00800 ){
            buf[0] = 0xc0 + (u8)((ch>>6)&0x1f);
            buf[1] = 0x80 + (u8)(ch & 0x3f);
            length = 2;
          }else if( ch<0x10000 ){
            buf[0] = 0xe0 + (u8)((ch>>12)&0x0f);
            buf[1] = 0x80 + (u8)((ch>>6) & 0x3f);
            buf[2] = 0x80 + (u8)(ch & 0x3f);
            length = 3;
          }else{
            buf[0] = 0xf0 + (u8)((ch>>18) & 0x07);
            buf[1] = 0x80 + (u8)((ch>>12) & 0x3f);
            buf[2] = 0x80 + (u8)((ch>>6) & 0x3f);
            buf[3] = 0x80 + (u8)(ch & 0x3f);
            length = 4;
          }
        }
        if( precision>1 ){
          width -= precision-1;
          if( width>1 && !flag_leftjustify ){
            sqlite3_str_appendchar(pAccum, width-1, ' ');
            width = 0;
          }
          while( precision-- > 1 ){
            sqlite3_str_append(pAccum, buf, length);
          }
        }
        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 etSQLESCAPE:           /* %q: Escape ' characters */
      case etSQLESCAPE2:          /* %Q: Escape ' and enclose in '...' */
      case etSQLESCAPE3: {        /* %w: Escape " characters */
        int i, j, k, n, isnull;
        int needQuote;
        char ch;
        char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
        char *escarg;
 
        if( bArgList ){
          escarg = getTextArg(pArgList);
        }else{
          escarg = va_arg(ap,char*);
        }
        isnull = escarg==0;
        if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
        /* 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++; }
          }
        }
        needQuote = !isnull && xtype==etSQLESCAPE2;
        n += i + 3;
        if( n>etBUFSIZE ){
          bufpt = zExtra = printfTempBuf(pAccum, n);
          if( bufpt==0 ) return;
        }else{
          bufpt = buf;
        }
        j = 0;
        if( needQuote ) bufpt[j++] = q;
        k = i;
        for(i=0; i<k; i++){
          bufpt[j++] = ch = escarg[i];
          if( ch==q ) bufpt[j++] = ch;
        }
        if( needQuote ) bufpt[j++] = q;
        bufpt[j] = 0;
        length = j;
        goto adjust_width_for_utf8;
      }
      case etTOKEN: {
        Token *pToken;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        pToken = va_arg(ap, Token*);
        assert( bArgList==0 );
        if( pToken && pToken->n ){
          sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
        }
        length = width = 0;
        break;
      }
      case etSRCLIST: {
        SrcList *pSrc;
        int k;
        struct SrcList_item *pItem;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
        pSrc = va_arg(ap, SrcList*);
        k = va_arg(ap, int);
        pItem = &pSrc->a[k];
        assert( bArgList==0 );
        assert( k>=0 && k<pSrc->nSrc );
        if( pItem->zDatabase ){
          sqlite3_str_appendall(pAccum, pItem->zDatabase);
          sqlite3_str_append(pAccum, ".", 1);
        }
        sqlite3_str_appendall(pAccum, pItem->zName);
        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 SrcList::a, sqlite3_str::accError, aDigits, aPrefix, ArraySize, arRound, et_info::base, et_info::charset, sqlite3_str::db, deliberate_fall_through, et_getdigit(), etBUFSIZE, etCHARX, etDECIMAL, etDYNSTRING, etEXP, etFLOAT, etGENERIC, etINVALID, etORDINAL, etPERCENT, etPOINTER, etRADIX, etSIZE, etSQLESCAPE, etSQLESCAPE2, etSQLESCAPE3, etSRCLIST, etSTRING, etTOKEN, FLAG_SIGNED, et_info::flags, fmtinfo, getDoubleArg(), getIntArg(), getTextArg(), LONGDOUBLE_TYPE, MAX, sqlite3_str::mxAlloc, Token::n, sqlite3_str::nAlloc, sqlite3_str::nChar, et_info::prefix, sqlite3_str::printfFlags, printfTempBuf(), SMALLEST_INT64, sqlite3_str_append(), sqlite3_str_appendall(), sqlite3_str_appendchar(), sqlite3DbFree(), sqlite3DbMallocSize(), sqlite3IsNaN(), SQLITE_FP_PRECISION_LIMIT, SQLITE_PRINTF_INTERNAL, SQLITE_PRINTF_MALLOCED, SQLITE_PRINTF_SQLFUNC, SQLITE_SKIP_UTF8, testcase, et_info::type, Token::z, and sqlite3_str::zText.

Referenced by renderLogMsg(), and sqlite3_str_appendf().

◆ sqlite3_strglob()

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

Definition at line 117856 of file sqlite3.c.

Referenced by decodeIntArray().

◆ sqlite3_stricmp()

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

Definition at line 31460 of file sqlite3.c.

                    : 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 ){

Referenced by analysisLoader(), isSelfJoinView(), lookupName(), parseModifier(), renameColumnElistNames(), renameColumnFunc(), renameColumnIdlistNames(), renameTableFunc(), resolveAsName(), sqlite3AddColumn(), sqlite3CheckObjectName(), sqlite3ExprCompare(), sqlite3FindDbName(), sqlite3FkCheck(), sqlite3FkRequired(), sqlite3GenerateRowDelete(), sqlite3Pragma(), sqlite3Select(), xferCompatibleIndex(), and xferOptimization().

◆ sqlite3_strlike()

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

Definition at line 117864 of file sqlite3.c.

Referenced by analyzeOneTable(), and sqlite3VdbeExec().

◆ sqlite3_strnicmp()

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

Definition at line 31487 of file sqlite3.c.

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

Referenced by codeInteger(), execSql(), parseModifier(), sqlite3InitCallback(), sqlite3IsShadowTableOf(), sqlite3LoadExtension(), sqlite3LocateTable(), sqlite3PragmaVtabRegister(), and yy_reduce().

◆ sqlite3_system_errno()

SQLITE_API int sqlite3_system_errno ( sqlite3 * db )

Definition at line 163571 of file sqlite3.c.

163572 {

163573 return SQLITE_NOMEM_BKPT;

◆ sqlite3_table_column_metadata()

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

Definition at line 164634 of file sqlite3.c.

 {
  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 || pTab->pSelect ){
    pTab = 0;
    goto error_out;
  }
 
  /* Find the column for which info is requested */
  if( zColumnName==0 ){
    /* Query for existance of table only */
  }else{
    for(iCol=0; iCol<pTab->nCol; iCol++){
      pCol = &pTab->aCol[iCol];
      if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
        break;
      }
    }
    if( iCol==pTab->nCol ){
      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 = pCol->zColl;
    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;
  }

References Table::aCol, COLFLAG_PRIMKEY, Column::colFlags, HasRowid, Table::iPKey, sqlite3::mutex, Table::nCol, Column::notNull, Table::pSelect, sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3ApiExit(), sqlite3BtreeEnterAll(), sqlite3BtreeLeaveAll(), sqlite3ColumnType(), sqlite3DbFree(), sqlite3ErrorWithMsg(), sqlite3FindTable(), sqlite3Init(), sqlite3IsRowid(), sqlite3MPrintf(), sqlite3SafetyCheckOk(), sqlite3StrBINARY, sqlite3StrICmp(), SQLITE_ERROR, SQLITE_MISUSE_BKPT, SQLITE_OK, Table::tabFlags, TF_Autoincrement, Column::zColl, and Column::zName.

◆ sqlite3_test_control()

SQLITE_API int sqlite3_test_control	(	int	op,
			... )

Definition at line 164829 of file sqlite3.c.

                                                {
  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(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: {
      /* MSVC is picky about pulling func ptrs from va lists.
      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
      */
      typedef int(*TESTCALLBACKFUNC_t)(int);
      sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
      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;
      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 = (u16)(va_arg(ap, int) & 0xffff);
      break;
    }
 
    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, subsequent calls to localtime()
    ** and its variants fail. If onoff is zero, undo this setting.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      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 demonstrat 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*);
      sqlite3_mutex_enter(db->mutex);
      db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
      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_thread_cleanup()

SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup ( void )

Definition at line 164626 of file sqlite3.c.

◆ sqlite3_threadsafe()

SQLITE_API int sqlite3_threadsafe ( void )

Definition at line 161123 of file sqlite3.c.

161123{ return SQLITE_VERSION_NUMBER; }

SQLITE_VERSION_NUMBER

#define SQLITE_VERSION_NUMBER

Definition sqlite3.c:1175

References SQLITE_VERSION_NUMBER.

◆ sqlite3_total_changes()

SQLITE_API int sqlite3_total_changes ( sqlite3 * db )

Definition at line 162095 of file sqlite3.c.

                                                 {
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){

Referenced by db_total_changes().

◆ sqlite3_trace()

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

Definition at line 163075 of file sqlite3.c.

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

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

Referenced by db_trace().

◆ sqlite3_trace_v2()

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

Definition at line 163096 of file sqlite3.c.

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

◆ sqlite3_transfer_bindings()

SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings	(	sqlite3_stmt *	pFromStmt,
		sqlite3_stmt *	pToStmt )

Definition at line 84622 of file sqlite3.c.

                                                                                        {
  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_ERROR, and SQLITE_PREPARE_SAVESQL.

◆ sqlite3_unlock_notify()

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

◆ sqlite3_update_hook()

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

Definition at line 163181 of file sqlite3.c.

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

Referenced by db_update_hook().

◆ sqlite3_uri_boolean()

SQLITE_API int sqlite3_uri_boolean	(	const char *	zFile,
		const char *	zParam,
		int	bDefault )

Definition at line 165318 of file sqlite3.c.

                                  : 0;
}
 
/*
** Return a boolean value for a query parameter.

Referenced by sqlite3PagerOpen(), and unixOpenSharedMemory().

◆ sqlite3_uri_int64()

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

Definition at line 165327 of file sqlite3.c.

                                         : 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 */
){
  const char *z = sqlite3_uri_parameter(zFilename, zParam);

◆ sqlite3_uri_key()

SQLITE_API const char * sqlite3_uri_key	(	const char *	zFilename,
		int	N )

Definition at line 165304 of file sqlite3.c.

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

◆ sqlite3_uri_parameter()

SQLITE_API const char * sqlite3_uri_parameter	(	const char *	zFilename,
		const char *	zParam )

Definition at line 165295 of file sqlite3.c.

References databaseName().

Referenced by findCreateFileMode().

◆ sqlite3_user_data()

SQLITE_API void * sqlite3_user_data ( sqlite3_context * p )

Definition at line 83779 of file sqlite3.c.

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

Referenced by db_sql_finalize_function(), db_sql_normal_function(), lcontext_check_aggregate(), lcontext_user_data(), likeFunc(), minmaxStep(), and sqlite3InvalidFunction().

◆ sqlite3_value_blob()

SQLITE_API const void * sqlite3_value_blob ( sqlite3_value * pVal )

Definition at line 83153 of file sqlite3.c.

                                                              {
  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_OK, and sqlite3_value::z.

Referenced by db_push_value(), instrFunc(), quoteFunc(), statGet(), statPush(), and substrFunc().

◆ sqlite3_value_bytes()

SQLITE_API int sqlite3_value_bytes ( sqlite3_value * pVal )

Definition at line 83166 of file sqlite3.c.

83167 : 0;

83168 }else{

Referenced by db_push_value(), instrFunc(), isDate(), likeFunc(), quoteFunc(), replaceFunc(), statPush(), and substrFunc().

◆ sqlite3_value_bytes16()

SQLITE_API int sqlite3_value_bytes16 ( sqlite3_value * pVal )

Definition at line 83169 of file sqlite3.c.

◆ sqlite3_value_double()

SQLITE_API double sqlite3_value_double ( sqlite3_value * pVal )

Definition at line 83172 of file sqlite3.c.

                                                       {
  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
}

References sqlite3ValueBytes(), and SQLITE_UTF8.

Referenced by absFunc(), db_push_value(), isDate(), and quoteFunc().

◆ sqlite3_value_dup()

SQLITE_API sqlite3_value * sqlite3_value_dup ( const sqlite3_value * pOrig )

Definition at line 83313 of file sqlite3.c.

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

References sqlite3_value::flags, and MEM_FromBind.

Referenced by instrFunc().

◆ sqlite3_value_free()

SQLITE_API void sqlite3_value_free ( sqlite3_value * pOld )

Definition at line 83336 of file sqlite3.c.

Referenced by instrFunc(), and last_valueValueFunc().

◆ sqlite3_value_frombind()

SQLITE_API int sqlite3_value_frombind ( sqlite3_value * pVal )

Definition at line 83307 of file sqlite3.c.

83308 {

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

References sqlite3_value::flags, MEM_Null, and MEM_Zero.

◆ sqlite3_value_int()

SQLITE_API int sqlite3_value_int ( sqlite3_value * pVal )

Definition at line 83175 of file sqlite3.c.

                                                         {
  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueBytes(), and SQLITE_UTF16NATIVE.

Referenced by compileoptiongetFunc(), errlogFunc(), renameColumnFunc(), renameTableFunc(), renameTableTest(), statGet(), statInit(), statPush(), substrFunc(), and windowExprGtZero().

◆ sqlite3_value_int64()

SQLITE_API sqlite3_int64 sqlite3_value_int64 ( sqlite3_value * pVal )

Definition at line 83178 of file sqlite3.c.

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

References sqlite3VdbeRealValue().

Referenced by absFunc(), charFunc(), db_push_value(), ntileStepFunc(), statInit(), statPush(), and sumStep().

◆ sqlite3_value_nochange()

SQLITE_API int sqlite3_value_nochange ( sqlite3_value * pVal )

Definition at line 83302 of file sqlite3.c.

Referenced by sqlite3_vtab_nochange(), and sqlite3VdbeMemExpandBlob().

◆ sqlite3_value_numeric_type()

SQLITE_API int sqlite3_value_numeric_type ( sqlite3_value * pVal )

Definition at line 85640 of file sqlite3.c.

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

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

Referenced by sumStep().

◆ sqlite3_value_pointer()

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

Definition at line 83185 of file sqlite3.c.

                                                                  {
  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()

SQLITE_API unsigned int sqlite3_value_subtype ( sqlite3_value * pVal )

Definition at line 83181 of file sqlite3.c.

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

References sqlite3VdbeIntValue().

◆ sqlite3_value_text()

SQLITE_API const unsigned char * sqlite3_value_text ( sqlite3_value * pVal )

Definition at line 83198 of file sqlite3.c.

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

References sqlite3_value::z.

Referenced by attachFunc(), columnName(), compileoptionusedFunc(), db_push_value(), detachFunc(), errlogFunc(), exprCompareVariable(), instrFunc(), isDate(), isLikeOrGlob(), likeFunc(), loadExt(), quoteFunc(), renameColumnFunc(), renameColumnParseError(), renameTableFunc(), renameTableTest(), replaceFunc(), sqlite3_step(), sqlite3VdbeExec(), strftimeFunc(), and substrFunc().

◆ sqlite3_value_text16()

SQLITE_API const void * sqlite3_value_text16 ( sqlite3_value * pVal )

Definition at line 83202 of file sqlite3.c.

83204 {

Referenced by columnName(), sqlite3_column_type(), and sqlite3_errmsg16().

◆ sqlite3_value_text16be()

SQLITE_API const void * sqlite3_value_text16be ( sqlite3_value * pVal )

Definition at line 83205 of file sqlite3.c.

◆ sqlite3_value_text16le()

SQLITE_API const void * sqlite3_value_text16le ( sqlite3_value * pVal )

Definition at line 83208 of file sqlite3.c.

                                                                {
  return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
}

References sqlite3ValueText(), and SQLITE_UTF16NATIVE.

◆ sqlite3_value_type()

SQLITE_API int sqlite3_value_type ( sqlite3_value * pVal )

Definition at line 83216 of file sqlite3.c.

                                                      {
  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_TEXT,     /* 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;

Referenced by absFunc(), db_push_value(), exprCompareVariable(), instrFunc(), isDate(), isLikeOrGlob(), likeFunc(), minmaxStep(), quoteFunc(), replaceFunc(), sqlite3_value_numeric_type(), statPush(), and substrFunc().

◆ sqlite3_vfs_find()

SQLITE_API sqlite3_vfs * sqlite3_vfs_find ( const char * zVfsName )

Definition at line 23307 of file sqlite3.c.

                                                          {
  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 mutex, sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MUTEX_STATIC_MAIN, vfsList, and sqlite3_vfs::zName.

Referenced by attachFunc(), and sqlite3ParseUri().

◆ sqlite3_vfs_register()

SQLITE_API int sqlite3_vfs_register	(	sqlite3_vfs *	pVfs,
		int	makeDflt )

Definition at line 23353 of file sqlite3.c.

                                                                    {
  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, MUTEX_LOGIC, sqlite3_vfs::pNext, sqlite3_initialize(), sqlite3_mutex_enter(), sqlite3_mutex_leave(), sqlite3MutexAlloc(), SQLITE_MISUSE_BKPT, SQLITE_MUTEX_STATIC_MAIN, SQLITE_OK, vfsList, and vfsUnlink().

Referenced by sqlite3_os_init().

◆ sqlite3_vfs_unregister()

SQLITE_API int sqlite3_vfs_unregister ( sqlite3_vfs * pVfs )

Definition at line 23381 of file sqlite3.c.

                                                        {
  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()

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

Definition at line 29299 of file sqlite3.c.

                                                                  {
  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()

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

Definition at line 29348 of file sqlite3.c.

                                                                                      {
  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_MISUSE_BKPT.

◆ sqlite3_vtab_collation()

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

Definition at line 148920 of file sqlite3.c.

                                                                                      {
  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 = pHidden->pWC->a[iTerm].pExpr;
    if( pX->pLeft ){

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

◆ sqlite3_vtab_config()

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

Definition at line 140848 of file sqlite3.c.

                                                            {
  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;
      }
      default: {
        rc = SQLITE_MISUSE_BKPT;
        break;
      }
    }
    va_end(ap);

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

◆ sqlite3_vtab_nochange()

SQLITE_API int sqlite3_vtab_nochange ( sqlite3_context * p )

Definition at line 83813 of file sqlite3.c.

References sqlite3_context::pOut, and sqlite3_value_nochange().

◆ sqlite3_vtab_on_conflict()

SQLITE_API int sqlite3_vtab_on_conflict ( sqlite3 * db )

Definition at line 140830 of file sqlite3.c.

                                                    {
  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_FAIL, SQLITE_IGNORE, SQLITE_MISUSE_BKPT, SQLITE_REPLACE, SQLITE_ROLLBACK, and sqlite3::vtabOnConflict.

◆ sqlite3_wal_autocheckpoint()

SQLITE_API int sqlite3_wal_autocheckpoint	(	sqlite3 *	db,
		int	N )

Definition at line 163281 of file sqlite3.c.

                                                                  {
#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 ){
    sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));

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

Referenced by openDatabase(), and sqlite3Pragma().

◆ sqlite3_wal_checkpoint()

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

Definition at line 163391 of file sqlite3.c.

References sqlite3_wal_checkpoint_v2(), and SQLITE_CHECKPOINT_PASSIVE.

Referenced by sqlite3WalDefaultHook().

◆ sqlite3_wal_checkpoint_v2()

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

Definition at line 163329 of file sqlite3.c.

 {
#ifdef SQLITE_OMIT_WAL
  return SQLITE_OK;
#else
  int rc;                         /* Return code */
  int iDb = SQLITE_MAX_ATTACHED;  /* sqlite3.aDb[] index of db 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;
  }
 
  sqlite3_mutex_enter(db->mutex);
  if( zDb && zDb[0] ){
    iDb = sqlite3FindDbName(db, zDb);
  }
  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 ){
    AtomicStore(&db->u1.isInterrupted, 0);

Referenced by sqlite3_wal_checkpoint().

◆ sqlite3_wal_hook()

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

Definition at line 163302 of file sqlite3.c.

 {
#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;
  db->pWalArg = pArg;

Referenced by sqlite3_wal_autocheckpoint().

◆ sqlite3_win32_set_directory()

SQLITE_API int sqlite3_win32_set_directory	(	unsigned long	type,
		void *	zValue )

◆ sqlite3_win32_set_directory16()

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

◆ sqlite3_win32_set_directory8()

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

Variable Documentation

◆ sqlite3_data_directory

SQLITE_API SQLITE_EXTERN char* sqlite3_data_directory

Definition at line 6073 of file sqlite3.h.

◆ sqlite3_temp_directory

SQLITE_API SQLITE_EXTERN char* sqlite3_temp_directory

Definition at line 6036 of file sqlite3.h.

◆ sqlite3_version

SQLITE_API SQLITE_EXTERN const char sqlite3_version[]

Definition at line 162 of file sqlite3.h.

Data Structures

Macros

Typedefs

Functions

Variables

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

◆ 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_SCRATCH

◆ 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_CONSTRAINT

◆ SQLITE_CONSTRAINT_CHECK

◆ SQLITE_CONSTRAINT_COMMITHOOK

◆ SQLITE_CONSTRAINT_FOREIGNKEY